diff --git a/lib/compiler_rt/aulldiv.zig b/lib/compiler_rt/aulldiv.zig index 1ce8f80c9fbc..fcc77eb8b6e0 100644 --- a/lib/compiler_rt/aulldiv.zig +++ b/lib/compiler_rt/aulldiv.zig @@ -7,7 +7,7 @@ const common = @import("common.zig"); pub const panic = common.panic; comptime { - if (arch == .x86 and abi == .msvc and builtin.zig_backend != .stage2_c) { + if (arch == .x86 and abi == .msvc and builtin.zig_backend != .zsf_c) { // Don't let LLVM apply the stdcall name mangling on those MSVC builtins @export(_alldiv, .{ .name = "\x01__alldiv", .linkage = common.linkage, .visibility = common.visibility }); @export(_aulldiv, .{ .name = "\x01__aulldiv", .linkage = common.linkage, .visibility = common.visibility }); diff --git a/lib/compiler_rt/aullrem.zig b/lib/compiler_rt/aullrem.zig index a87ec26475f9..83c1b08c84ad 100644 --- a/lib/compiler_rt/aullrem.zig +++ b/lib/compiler_rt/aullrem.zig @@ -7,7 +7,7 @@ const common = @import("common.zig"); pub const panic = common.panic; comptime { - if (arch == .x86 and abi == .msvc and builtin.zig_backend != .stage2_c) { + if (arch == .x86 and abi == .msvc and builtin.zig_backend != .zsf_c) { // Don't let LLVM apply the stdcall name mangling on those MSVC builtins @export(_allrem, .{ .name = "\x01__allrem", .linkage = common.linkage, .visibility = common.visibility }); @export(_aullrem, .{ .name = "\x01__aullrem", .linkage = common.linkage, .visibility = common.visibility }); diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig index 752a4a46df8a..cd937a9b8f1a 100644 --- a/lib/compiler_rt/common.zig +++ b/lib/compiler_rt/common.zig @@ -84,8 +84,7 @@ pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, _: ? /// here in compiler-rt. pub fn F16T(comptime other_type: type) type { return switch (builtin.cpu.arch) { - .aarch64, .aarch64_be, .aarch64_32 => f16, - .riscv64 => if (builtin.zig_backend == .stage1) u16 else f16, + .aarch64, .aarch64_be, .aarch64_32, .riscv64 => f16, .x86, .x86_64 => if (builtin.target.isDarwin()) switch (other_type) { // Starting with LLVM 16, Darwin uses different abi for f16 // depending on the type of the other return/argument..??? diff --git a/lib/compiler_rt/divdc3.zig b/lib/compiler_rt/divdc3.zig index ddcb0b83ea49..7f0b2ba64649 100644 --- a/lib/compiler_rt/divdc3.zig +++ b/lib/compiler_rt/divdc3.zig @@ -3,7 +3,7 @@ const divc3 = @import("./divc3.zig"); const Complex = @import("./mulc3.zig").Complex; comptime { - if (@import("builtin").zig_backend != .stage2_c) { + if (@import("builtin").zig_backend != .zsf_c) { @export(__divdc3, .{ .name = "__divdc3", .linkage = common.linkage, .visibility = common.visibility }); } } diff --git a/lib/compiler_rt/divhc3.zig b/lib/compiler_rt/divhc3.zig index 7e9bfeb0fff8..84c997a7ffbf 100644 --- a/lib/compiler_rt/divhc3.zig +++ b/lib/compiler_rt/divhc3.zig @@ -3,7 +3,7 @@ const divc3 = @import("./divc3.zig"); const Complex = @import("./mulc3.zig").Complex; comptime { - if (@import("builtin").zig_backend != .stage2_c) { + if (@import("builtin").zig_backend != .zsf_c) { @export(__divhc3, .{ .name = "__divhc3", .linkage = common.linkage, .visibility = common.visibility }); } } diff --git a/lib/compiler_rt/divsc3.zig b/lib/compiler_rt/divsc3.zig index 20cdc56a0919..4e8cba9d181f 100644 --- a/lib/compiler_rt/divsc3.zig +++ b/lib/compiler_rt/divsc3.zig @@ -3,7 +3,7 @@ const divc3 = @import("./divc3.zig"); const Complex = @import("./mulc3.zig").Complex; comptime { - if (@import("builtin").zig_backend != .stage2_c) { + if (@import("builtin").zig_backend != .zsf_c) { @export(__divsc3, .{ .name = "__divsc3", .linkage = common.linkage, .visibility = common.visibility }); } } diff --git a/lib/compiler_rt/divtc3.zig b/lib/compiler_rt/divtc3.zig index fccce3459cbd..8a553b102fc3 100644 --- a/lib/compiler_rt/divtc3.zig +++ b/lib/compiler_rt/divtc3.zig @@ -3,7 +3,7 @@ const divc3 = @import("./divc3.zig"); const Complex = @import("./mulc3.zig").Complex; comptime { - if (@import("builtin").zig_backend != .stage2_c) { + if (@import("builtin").zig_backend != .zsf_c) { if (common.want_ppc_abi) @export(__divtc3, .{ .name = "__divkc3", .linkage = common.linkage, .visibility = common.visibility }); @export(__divtc3, .{ .name = "__divtc3", .linkage = common.linkage, .visibility = common.visibility }); diff --git a/lib/compiler_rt/divxc3.zig b/lib/compiler_rt/divxc3.zig index 177e26cfd847..f79d0333f232 100644 --- a/lib/compiler_rt/divxc3.zig +++ b/lib/compiler_rt/divxc3.zig @@ -3,7 +3,7 @@ const divc3 = @import("./divc3.zig"); const Complex = @import("./mulc3.zig").Complex; comptime { - if (@import("builtin").zig_backend != .stage2_c) { + if (@import("builtin").zig_backend != .zsf_c) { @export(__divxc3, .{ .name = "__divxc3", .linkage = common.linkage, .visibility = common.visibility }); } } diff --git a/lib/compiler_rt/muldc3.zig b/lib/compiler_rt/muldc3.zig index 3a497fdedcc5..a1721bf05da1 100644 --- a/lib/compiler_rt/muldc3.zig +++ b/lib/compiler_rt/muldc3.zig @@ -4,7 +4,7 @@ const mulc3 = @import("./mulc3.zig"); pub const panic = common.panic; comptime { - if (@import("builtin").zig_backend != .stage2_c) { + if (@import("builtin").zig_backend != .zsf_c) { @export(__muldc3, .{ .name = "__muldc3", .linkage = common.linkage, .visibility = common.visibility }); } } diff --git a/lib/compiler_rt/mulhc3.zig b/lib/compiler_rt/mulhc3.zig index cf44f1cc14ba..af61527d4f6f 100644 --- a/lib/compiler_rt/mulhc3.zig +++ b/lib/compiler_rt/mulhc3.zig @@ -4,7 +4,7 @@ const mulc3 = @import("./mulc3.zig"); pub const panic = common.panic; comptime { - if (@import("builtin").zig_backend != .stage2_c) { + if (@import("builtin").zig_backend != .zsf_c) { @export(__mulhc3, .{ .name = "__mulhc3", .linkage = common.linkage, .visibility = common.visibility }); } } diff --git a/lib/compiler_rt/mulsc3.zig b/lib/compiler_rt/mulsc3.zig index add389a59865..cbd0c9d4e837 100644 --- a/lib/compiler_rt/mulsc3.zig +++ b/lib/compiler_rt/mulsc3.zig @@ -4,7 +4,7 @@ const mulc3 = @import("./mulc3.zig"); pub const panic = common.panic; comptime { - if (@import("builtin").zig_backend != .stage2_c) { + if (@import("builtin").zig_backend != .zsf_c) { @export(__mulsc3, .{ .name = "__mulsc3", .linkage = common.linkage, .visibility = common.visibility }); } } diff --git a/lib/compiler_rt/multc3.zig b/lib/compiler_rt/multc3.zig index ae46bdeed85b..6785a0d663a3 100644 --- a/lib/compiler_rt/multc3.zig +++ b/lib/compiler_rt/multc3.zig @@ -4,7 +4,7 @@ const mulc3 = @import("./mulc3.zig"); pub const panic = common.panic; comptime { - if (@import("builtin").zig_backend != .stage2_c) { + if (@import("builtin").zig_backend != .zsf_c) { if (common.want_ppc_abi) @export(__multc3, .{ .name = "__mulkc3", .linkage = common.linkage, .visibility = common.visibility }); @export(__multc3, .{ .name = "__multc3", .linkage = common.linkage, .visibility = common.visibility }); diff --git a/lib/compiler_rt/mulxc3.zig b/lib/compiler_rt/mulxc3.zig index 8d836ef04d71..00b1b1f2f283 100644 --- a/lib/compiler_rt/mulxc3.zig +++ b/lib/compiler_rt/mulxc3.zig @@ -4,7 +4,7 @@ const mulc3 = @import("./mulc3.zig"); pub const panic = common.panic; comptime { - if (@import("builtin").zig_backend != .stage2_c) { + if (@import("builtin").zig_backend != .zsf_c) { @export(__mulxc3, .{ .name = "__mulxc3", .linkage = common.linkage, .visibility = common.visibility }); } } diff --git a/lib/compiler_rt/udivmodei4.zig b/lib/compiler_rt/udivmodei4.zig index f222c13a4c00..6447001e365e 100644 --- a/lib/compiler_rt/udivmodei4.zig +++ b/lib/compiler_rt/udivmodei4.zig @@ -129,7 +129,7 @@ pub fn __umodei4(r_p: [*]u32, u_p: [*]const u32, v_p: [*]const u32, bits: usize) } test "__udivei4/__umodei4" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO const RndGen = std.rand.DefaultPrng; var rnd = RndGen.init(42); diff --git a/lib/std/bit_set.zig b/lib/std/bit_set.zig index 9e5c707b84d0..c60216f99728 100644 --- a/lib/std/bit_set.zig +++ b/lib/std/bit_set.zig @@ -1636,7 +1636,7 @@ fn testStaticBitSet(comptime Set: type) !void { } test "IntegerBitSet" { - if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest; + if (@import("builtin").zig_backend == .zsf_c) return error.SkipZigTest; try testStaticBitSet(IntegerBitSet(0)); try testStaticBitSet(IntegerBitSet(1)); diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 439156ca6c0d..f7409469e4c0 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -667,42 +667,38 @@ pub const CompilerBackend = enum(u64) { /// in which case this value is appropriate. Be cool and make sure your /// code supports `other` Zig compilers! other = 0, - /// The original Zig compiler created in 2015 by Andrew Kelley. Implemented - /// in C++. Used LLVM. Deleted from the ZSF ziglang/zig codebase on - /// December 6th, 2022. - stage1 = 1, - /// The reference implementation self-hosted compiler of Zig, using the + /// The reference implementation by Zig Software Foundation, using the /// LLVM backend. - stage2_llvm = 2, - /// The reference implementation self-hosted compiler of Zig, using the + zsf_llvm = 1, + /// The reference implementation by Zig Software Foundation, using the /// backend that generates C source code. /// Note that one can observe whether the compilation will output C code /// directly with `object_format` value rather than the `compiler_backend` value. - stage2_c = 3, - /// The reference implementation self-hosted compiler of Zig, using the + zsf_c = 2, + /// The reference implementation by Zig Software Foundation, using the /// WebAssembly backend. - stage2_wasm = 4, - /// The reference implementation self-hosted compiler of Zig, using the + zsf_wasm = 3, + /// The reference implementation by Zig Software Foundation, using the /// arm backend. - stage2_arm = 5, - /// The reference implementation self-hosted compiler of Zig, using the + zsf_arm = 4, + /// The reference implementation by Zig Software Foundation, using the /// x86_64 backend. - stage2_x86_64 = 6, - /// The reference implementation self-hosted compiler of Zig, using the + zsf_x86_64 = 5, + /// The reference implementation by Zig Software Foundation, using the /// aarch64 backend. - stage2_aarch64 = 7, - /// The reference implementation self-hosted compiler of Zig, using the + zsf_aarch64 = 6, + /// The reference implementation by Zig Software Foundation, using the /// x86 backend. - stage2_x86 = 8, - /// The reference implementation self-hosted compiler of Zig, using the + zsf_x86 = 7, + /// The reference implementation by Zig Software Foundation, using the /// riscv64 backend. - stage2_riscv64 = 9, - /// The reference implementation self-hosted compiler of Zig, using the + zsf_riscv64 = 8, + /// The reference implementation by Zig Software Foundation, using the /// sparc64 backend. - stage2_sparc64 = 10, - /// The reference implementation self-hosted compiler of Zig, using the + zsf_sparc64 = 9, + /// The reference implementation by Zig Software Foundation, using the /// spirv backend. - stage2_spirv64 = 11, + zsf_spirv64 = 10, _, }; @@ -735,14 +731,14 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr // For backends that cannot handle the language features depended on by the // default panic handler, we have a simpler panic handler: - if (builtin.zig_backend == .stage2_wasm or - builtin.zig_backend == .stage2_arm or - builtin.zig_backend == .stage2_aarch64 or - builtin.zig_backend == .stage2_x86_64 or - builtin.zig_backend == .stage2_x86 or - builtin.zig_backend == .stage2_riscv64 or - builtin.zig_backend == .stage2_sparc64 or - builtin.zig_backend == .stage2_spirv64) + if (builtin.zig_backend == .zsf_wasm or + builtin.zig_backend == .zsf_arm or + builtin.zig_backend == .zsf_aarch64 or + builtin.zig_backend == .zsf_x86_64 or + builtin.zig_backend == .zsf_x86 or + builtin.zig_backend == .zsf_riscv64 or + builtin.zig_backend == .zsf_sparc64 or + builtin.zig_backend == .zsf_spirv64) { while (true) { @breakpoint(); diff --git a/lib/std/crypto/aes.zig b/lib/std/crypto/aes.zig index 70246e6630b0..c7186da4f619 100644 --- a/lib/std/crypto/aes.zig +++ b/lib/std/crypto/aes.zig @@ -6,9 +6,9 @@ const has_aesni = std.Target.x86.featureSetHas(builtin.cpu.features, .aes); const has_avx = std.Target.x86.featureSetHas(builtin.cpu.features, .avx); const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes); // C backend doesn't currently support passing vectors to inline asm. -const impl = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .stage2_c and has_aesni and has_avx) impl: { +const impl = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .zsf_c and has_aesni and has_avx) impl: { break :impl @import("aes/aesni.zig"); -} else if (builtin.cpu.arch == .aarch64 and builtin.zig_backend != .stage2_c and has_armaes) +} else if (builtin.cpu.arch == .aarch64 and builtin.zig_backend != .zsf_c and has_armaes) impl: { break :impl @import("aes/armcrypto.zig"); } else impl: { diff --git a/lib/std/crypto/aes_ocb.zig b/lib/std/crypto/aes_ocb.zig index fe287c370ac6..c2642d7ede84 100644 --- a/lib/std/crypto/aes_ocb.zig +++ b/lib/std/crypto/aes_ocb.zig @@ -257,7 +257,7 @@ inline fn xorWith(x: *Block, y: Block) void { const hexToBytes = std.fmt.hexToBytes; test "AesOcb test vector 1" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var k: [Aes128Ocb.key_length]u8 = undefined; var nonce: [Aes128Ocb.nonce_length]u8 = undefined; @@ -276,7 +276,7 @@ test "AesOcb test vector 1" { } test "AesOcb test vector 2" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var k: [Aes128Ocb.key_length]u8 = undefined; var nonce: [Aes128Ocb.nonce_length]u8 = undefined; @@ -297,7 +297,7 @@ test "AesOcb test vector 2" { } test "AesOcb test vector 3" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var k: [Aes128Ocb.key_length]u8 = undefined; var nonce: [Aes128Ocb.nonce_length]u8 = undefined; @@ -321,7 +321,7 @@ test "AesOcb test vector 3" { } test "AesOcb test vector 4" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var k: [Aes128Ocb.key_length]u8 = undefined; var nonce: [Aes128Ocb.nonce_length]u8 = undefined; diff --git a/lib/std/crypto/ecdsa.zig b/lib/std/crypto/ecdsa.zig index 1a5335b07e0b..0996475d1f89 100644 --- a/lib/std/crypto/ecdsa.zig +++ b/lib/std/crypto/ecdsa.zig @@ -372,7 +372,7 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type { } test "ECDSA - Basic operations over EcdsaP384Sha384" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; const Scheme = EcdsaP384Sha384; const kp = try Scheme.KeyPair.create(null); @@ -388,7 +388,7 @@ test "ECDSA - Basic operations over EcdsaP384Sha384" { } test "ECDSA - Basic operations over Secp256k1" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; const Scheme = EcdsaSecp256k1Sha256oSha256; const kp = try Scheme.KeyPair.create(null); @@ -404,7 +404,7 @@ test "ECDSA - Basic operations over Secp256k1" { } test "ECDSA - Basic operations over EcdsaP384Sha256" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256); const kp = try Scheme.KeyPair.create(null); @@ -420,7 +420,7 @@ test "ECDSA - Basic operations over EcdsaP384Sha256" { } test "ECDSA - Verifying a existing signature with EcdsaP384Sha256" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256); // zig fmt: off @@ -464,7 +464,7 @@ const TestVector = struct { }; test "ECDSA - Test vectors from Project Wycheproof" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; const vectors = [_]TestVector{ .{ .key = "042927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e", .msg = "313233343030", .sig = "304402202ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e1802204cd60b855d442f5b3c7b11eb6c4e0ae7525fe710fab9aa7c77a67f79e6fadd76", .result = .valid }, @@ -878,7 +878,7 @@ fn tvTry(vector: TestVector) !void { } test "ECDSA - Sec1 encoding/decoding" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; const Scheme = EcdsaP384Sha384; const kp = try Scheme.KeyPair.create(null); diff --git a/lib/std/crypto/ff.zig b/lib/std/crypto/ff.zig index aec17cc7d56f..ab270dc33902 100644 --- a/lib/std/crypto/ff.zig +++ b/lib/std/crypto/ff.zig @@ -854,7 +854,7 @@ const ct_unprotected = struct { }; test { - if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest; + if (@import("builtin").zig_backend == .zsf_c) return error.SkipZigTest; const M = Modulus(256); const m = try M.fromPrimitive(u256, 3429938563481314093726330772853735541133072814650493833233); diff --git a/lib/std/crypto/ghash_polyval.zig b/lib/std/crypto/ghash_polyval.zig index 11379cc8e3ea..910c2ee6f551 100644 --- a/lib/std/crypto/ghash_polyval.zig +++ b/lib/std/crypto/ghash_polyval.zig @@ -293,9 +293,9 @@ fn Hash(comptime endian: std.builtin.Endian, comptime shift_key: bool) type { const has_avx = std.Target.x86.featureSetHas(builtin.cpu.features, .avx); const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes); // C backend doesn't currently support passing vectors to inline asm. - const clmul = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .stage2_c and has_pclmul and has_avx) impl: { + const clmul = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .zsf_c and has_pclmul and has_avx) impl: { break :impl clmulPclmul; - } else if (builtin.cpu.arch == .aarch64 and builtin.zig_backend != .stage2_c and has_armaes) impl: { + } else if (builtin.cpu.arch == .aarch64 and builtin.zig_backend != .zsf_c and has_armaes) impl: { break :impl clmulPmull; } else impl: { break :impl clmulSoft; diff --git a/lib/std/crypto/pcurves/p384.zig b/lib/std/crypto/pcurves/p384.zig index d5afd6eb4ddd..000e74642bbe 100644 --- a/lib/std/crypto/pcurves/p384.zig +++ b/lib/std/crypto/pcurves/p384.zig @@ -478,7 +478,7 @@ pub const AffineCoordinates = struct { }; test { - if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest; + if (@import("builtin").zig_backend == .zsf_c) return error.SkipZigTest; _ = @import("tests/p384.zig"); } diff --git a/lib/std/crypto/pcurves/secp256k1.zig b/lib/std/crypto/pcurves/secp256k1.zig index cd7f1faf755c..ff3f3262ed1d 100644 --- a/lib/std/crypto/pcurves/secp256k1.zig +++ b/lib/std/crypto/pcurves/secp256k1.zig @@ -556,7 +556,7 @@ pub const AffineCoordinates = struct { }; test { - if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest; + if (@import("builtin").zig_backend == .zsf_c) return error.SkipZigTest; _ = @import("tests/secp256k1.zig"); } diff --git a/lib/std/crypto/sha2.zig b/lib/std/crypto/sha2.zig index f87ea90d9277..0708faa29302 100644 --- a/lib/std/crypto/sha2.zig +++ b/lib/std/crypto/sha2.zig @@ -200,7 +200,7 @@ fn Sha2x32(comptime params: Sha2Params32) type { if (!@inComptime()) { switch (builtin.cpu.arch) { - .aarch64 => if (builtin.zig_backend != .stage2_c and comptime std.Target.aarch64.featureSetHas(builtin.cpu.features, .sha2)) { + .aarch64 => if (builtin.zig_backend != .zsf_c and comptime std.Target.aarch64.featureSetHas(builtin.cpu.features, .sha2)) { var x: v4u32 = d.s[0..4].*; var y: v4u32 = d.s[4..8].*; const s_v = @as(*[16]v4u32, @ptrCast(&s)); @@ -238,7 +238,7 @@ fn Sha2x32(comptime params: Sha2Params32) type { return; }, // C backend doesn't currently support passing vectors to inline asm. - .x86_64 => if (builtin.zig_backend != .stage2_c and comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sha, .avx2 })) { + .x86_64 => if (builtin.zig_backend != .zsf_c and comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sha, .avx2 })) { var x: v4u32 = [_]u32{ d.s[5], d.s[4], d.s[1], d.s[0] }; var y: v4u32 = [_]u32{ d.s[7], d.s[6], d.s[3], d.s[2] }; const s_v = @as(*[16]v4u32, @ptrCast(&s)); diff --git a/lib/std/http/Client.zig b/lib/std/http/Client.zig index cefa77c25dab..16ed217cd576 100644 --- a/lib/std/http/Client.zig +++ b/lib/std/http/Client.zig @@ -1042,7 +1042,7 @@ pub fn request(client: *Client, method: http.Method, uri: Uri, headers: http.Hea test { const builtin = @import("builtin"); const native_endian = comptime builtin.cpu.arch.endian(); - if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) { + if (builtin.zig_backend == .zsf_llvm and native_endian == .Big) { // https://github.com/ziglang/zig/issues/13782 return error.SkipZigTest; } diff --git a/lib/std/http/Server.zig b/lib/std/http/Server.zig index 59d404a81a0d..780a4ce77310 100644 --- a/lib/std/http/Server.zig +++ b/lib/std/http/Server.zig @@ -715,7 +715,7 @@ test "HTTP server handles a chunked transfer coding request" { } const native_endian = comptime builtin.cpu.arch.endian(); - if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) { + if (builtin.zig_backend == .zsf_llvm and native_endian == .Big) { // https://github.com/ziglang/zig/issues/13782 return error.SkipZigTest; } diff --git a/lib/std/io.zig b/lib/std/io.zig index e7a4476c0f4c..6b789fd97e30 100644 --- a/lib/std/io.zig +++ b/lib/std/io.zig @@ -29,7 +29,7 @@ pub const default_mode: ModeOverride = if (is_async) Mode.evented else .blocking fn getStdOutHandle() os.fd_t { if (builtin.os.tag == .windows) { - if (builtin.zig_backend == .stage2_aarch64) { + if (builtin.zig_backend == .zsf_aarch64) { // TODO: this is just a temporary workaround until we advance aarch64 backend further along. return os.windows.GetStdHandle(os.windows.STD_OUTPUT_HANDLE) catch os.windows.INVALID_HANDLE_VALUE; } @@ -55,7 +55,7 @@ pub fn getStdOut() File { fn getStdErrHandle() os.fd_t { if (builtin.os.tag == .windows) { - if (builtin.zig_backend == .stage2_aarch64) { + if (builtin.zig_backend == .zsf_aarch64) { // TODO: this is just a temporary workaround until we advance aarch64 backend further along. return os.windows.GetStdHandle(os.windows.STD_ERROR_HANDLE) catch os.windows.INVALID_HANDLE_VALUE; } @@ -81,7 +81,7 @@ pub fn getStdErr() File { fn getStdInHandle() os.fd_t { if (builtin.os.tag == .windows) { - if (builtin.zig_backend == .stage2_aarch64) { + if (builtin.zig_backend == .zsf_aarch64) { // TODO: this is just a temporary workaround until we advance aarch64 backend further along. return os.windows.GetStdHandle(os.windows.STD_INPUT_HANDLE) catch os.windows.INVALID_HANDLE_VALUE; } diff --git a/lib/std/math.zig b/lib/std/math.zig index 6d5faeb7eed7..0764245dca8e 100644 --- a/lib/std/math.zig +++ b/lib/std/math.zig @@ -524,7 +524,7 @@ pub fn shl(comptime T: type, a: T, shift_amt: anytype) T { } test "shl" { - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .aarch64) { // https://github.com/ziglang/zig/issues/12012 return error.SkipZigTest; } @@ -568,7 +568,7 @@ pub fn shr(comptime T: type, a: T, shift_amt: anytype) T { } test "shr" { - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .aarch64) { // https://github.com/ziglang/zig/issues/12012 return error.SkipZigTest; } @@ -613,7 +613,7 @@ pub fn rotr(comptime T: type, x: T, r: anytype) T { } test "rotr" { - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .aarch64) { // https://github.com/ziglang/zig/issues/12012 return error.SkipZigTest; } @@ -657,7 +657,7 @@ pub fn rotl(comptime T: type, x: T, r: anytype) T { } test "rotl" { - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .aarch64) { // https://github.com/ziglang/zig/issues/12012 return error.SkipZigTest; } @@ -1816,7 +1816,7 @@ fn testSign() !void { } test "sign" { - if (builtin.zig_backend == .stage2_llvm) { + if (builtin.zig_backend == .zsf_llvm) { // https://github.com/ziglang/zig/issues/12012 return error.SkipZigTest; } diff --git a/lib/std/math/big/int_test.zig b/lib/std/math/big/int_test.zig index 6f1133d21f4a..bf04230627bd 100644 --- a/lib/std/math/big/int_test.zig +++ b/lib/std/math/big/int_test.zig @@ -915,7 +915,7 @@ test "big.int mul multi-single" { } test "big.int mul multi-multi" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var op1: u256 = 0x998888efefefefefefefef; var op2: u256 = 0x333000abababababababab; @@ -1036,7 +1036,7 @@ test "big.int mulWrap single-single signed" { } test "big.int mulWrap multi-multi unsigned" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var op1: u256 = 0x998888efefefefefefefef; var op2: u256 = 0x333000abababababababab; @@ -1053,7 +1053,7 @@ test "big.int mulWrap multi-multi unsigned" { } test "big.int mulWrap multi-multi signed" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var a = try Managed.initSet(testing.allocator, maxInt(SignedDoubleLimb) - 1); defer a.deinit(); @@ -1258,7 +1258,7 @@ test "big.int div q=0 alias" { } test "big.int div multi-multi q < r" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; const op1 = 0x1ffffffff0078f432; const op2 = 0x1ffffffff01000000; @@ -1629,7 +1629,7 @@ test "big.int div floor positive close to zero" { } test "big.int div multi-multi with rem" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var a = try Managed.initSet(testing.allocator, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999); defer a.deinit(); @@ -1647,7 +1647,7 @@ test "big.int div multi-multi with rem" { } test "big.int div multi-multi no rem" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var a = try Managed.initSet(testing.allocator, 0x8888999911110000ffffeeeedb4fec200ee3a4286361); defer a.deinit(); @@ -1665,7 +1665,7 @@ test "big.int div multi-multi no rem" { } test "big.int div multi-multi (2 branch)" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var a = try Managed.initSet(testing.allocator, 0x866666665555555588888887777777761111111111111111); defer a.deinit(); @@ -1683,7 +1683,7 @@ test "big.int div multi-multi (2 branch)" { } test "big.int div multi-multi (3.1/3.3 branch)" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var a = try Managed.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111); defer a.deinit(); @@ -1701,7 +1701,7 @@ test "big.int div multi-multi (3.1/3.3 branch)" { } test "big.int div multi-single zero-limb trailing" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var a = try Managed.initSet(testing.allocator, 0x60000000000000000000000000000000000000000000000000000000000000000); defer a.deinit(); @@ -1721,7 +1721,7 @@ test "big.int div multi-single zero-limb trailing" { } test "big.int div multi-multi zero-limb trailing (with rem)" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var a = try Managed.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000); defer a.deinit(); @@ -1742,7 +1742,7 @@ test "big.int div multi-multi zero-limb trailing (with rem)" { } test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var a = try Managed.initSet(testing.allocator, 0x8666666655555555888888877777777611111111111111110000000000000000); defer a.deinit(); @@ -1763,7 +1763,7 @@ test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-li } test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var a = try Managed.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000); defer a.deinit(); @@ -2158,13 +2158,13 @@ test "big.int bitNotWrap signed multi" { test "big.int bitNotWrap more than two limbs" { // This test requires int sizes greater than 128 bits. - 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO // LLVM: unexpected runtime library name: __umodei4 - if (builtin.zig_backend == .stage2_llvm and comptime builtin.target.isWasm()) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_llvm and comptime builtin.target.isWasm()) return error.SkipZigTest; // TODO var a = try Managed.initSet(testing.allocator, maxInt(Limb)); defer a.deinit(); @@ -2518,7 +2518,7 @@ test "big.int gcd non-one large" { } test "big.int gcd large multi-limb result" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var a = try Managed.initSet(testing.allocator, 0x12345678123456781234567812345678123456781234567812345678); defer a.deinit(); diff --git a/lib/std/math/log10.zig b/lib/std/math/log10.zig index 785f11771ca5..9acbc32a8796 100644 --- a/lib/std/math/log10.zig +++ b/lib/std/math/log10.zig @@ -145,13 +145,13 @@ test "oldlog10 doesn't work" { } test "log10_int vs old implementation" { - 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_llvm and comptime builtin.target.isWasm()) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_llvm and comptime builtin.target.isWasm()) return error.SkipZigTest; // TODO const int_types = .{ u8, u16, u32, u64, u128 }; @@ -168,13 +168,13 @@ test "log10_int vs old implementation" { } test "log10_int close to powers of 10" { - 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_llvm and comptime builtin.target.isWasm()) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_llvm and comptime builtin.target.isWasm()) return error.SkipZigTest; // TODO const int_types = .{ u8, u16, u32, u64, u128, u256, u512 }; const max_log_values: [7]usize = .{ 2, 4, 9, 19, 38, 77, 154 }; diff --git a/lib/std/mem.zig b/lib/std/mem.zig index 0b6306f1ed5a..12ebeb297feb 100644 --- a/lib/std/mem.zig +++ b/lib/std/mem.zig @@ -316,7 +316,7 @@ pub fn zeroes(comptime T: type) T { } test "zeroes" { - if (builtin.zig_backend == .stage2_llvm) { + if (builtin.zig_backend == .zsf_llvm) { // Regressed in LLVM 14: // https://github.com/llvm/llvm-project/issues/55522 return error.SkipZigTest; @@ -1591,7 +1591,7 @@ test "comptime read/write int" { } test "readIntBig and readIntLittle" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; try testing.expect(readIntSliceBig(u0, &[_]u8{}) == 0x0); try testing.expect(readIntSliceLittle(u0, &[_]u8{}) == 0x0); @@ -1883,7 +1883,7 @@ pub fn writeVarPackedInt(bytes: []u8, bit_offset: usize, bit_count: usize, value } test "writeIntBig and writeIntLittle" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var buf0: [0]u8 = undefined; var buf1: [1]u8 = undefined; @@ -4272,7 +4272,7 @@ pub fn doNotOptimizeAway(val: anytype) void { .Bool => doNotOptimizeAway(@intFromBool(val)), .Int => { const bits = t.Int.bits; - if (bits <= max_gp_register_bits and builtin.zig_backend != .stage2_c) { + if (bits <= max_gp_register_bits and builtin.zig_backend != .zsf_c) { const val2 = @as( std.meta.Int(t.Int.signedness, @max(8, std.math.ceilPowerOfTwoAssert(u16, bits))), val, @@ -4284,7 +4284,7 @@ pub fn doNotOptimizeAway(val: anytype) void { } else doNotOptimizeAway(&val); }, .Float => { - if ((t.Float.bits == 32 or t.Float.bits == 64) and builtin.zig_backend != .stage2_c) { + if ((t.Float.bits == 32 or t.Float.bits == 64) and builtin.zig_backend != .zsf_c) { asm volatile ("" : : [val] "rm" (val), @@ -4292,7 +4292,7 @@ pub fn doNotOptimizeAway(val: anytype) void { } else doNotOptimizeAway(&val); }, .Pointer => { - if (builtin.zig_backend == .stage2_c) { + if (builtin.zig_backend == .zsf_c) { doNotOptimizeAwayC(val); } else { asm volatile ("" @@ -4311,8 +4311,8 @@ pub fn doNotOptimizeAway(val: anytype) void { } } -/// .stage2_c doesn't support asm blocks yet, so use volatile stores instead -var deopt_target: if (builtin.zig_backend == .stage2_c) u8 else void = undefined; +/// .zsf_c doesn't support asm blocks yet, so use volatile stores instead +var deopt_target: if (builtin.zig_backend == .zsf_c) u8 else void = undefined; fn doNotOptimizeAwayC(ptr: anytype) void { const dest = @as(*volatile u8, @ptrCast(&deopt_target)); for (asBytes(ptr)) |b| { @@ -4481,7 +4481,7 @@ pub fn alignInSlice(slice: anytype, comptime new_alignment: usize) ?AlignedSlice } test "read/write(Var)PackedInt" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; switch (builtin.cpu.arch) { // This test generates too much code to execute on WASI. diff --git a/lib/std/os.zig b/lib/std/os.zig index 0a1bcc9ac1e0..6fde12e495bc 100644 --- a/lib/std/os.zig +++ b/lib/std/os.zig @@ -5516,7 +5516,7 @@ pub fn toPosixPath(file_path: []const u8) ![MAX_PATH_BYTES - 1:0]u8 { /// if this happens the fix is to add the error code to the corresponding /// switch expression, possibly introduce a new error in the error set, and /// send a patch to Zig. -pub const unexpected_error_tracing = builtin.zig_backend == .stage2_llvm and builtin.mode == .Debug; +pub const unexpected_error_tracing = builtin.zig_backend == .zsf_llvm and builtin.mode == .Debug; pub const UnexpectedError = error{ /// The Operating System returned an undocumented error code. diff --git a/lib/std/os/linux/arm-eabi.zig b/lib/std/os/linux/arm-eabi.zig index f4870dccbb9e..227981d1f0b7 100644 --- a/lib/std/os/linux/arm-eabi.zig +++ b/lib/std/os/linux/arm-eabi.zig @@ -105,7 +105,7 @@ pub extern fn clone(func: CloneFn, stack: usize, flags: u32, arg: usize, ptid: * pub fn restore() callconv(.Naked) noreturn { switch (@import("builtin").zig_backend) { - .stage2_c => asm volatile ( + .zsf_c => asm volatile ( \\ mov r7, %[number] \\ svc #0 : @@ -123,7 +123,7 @@ pub fn restore() callconv(.Naked) noreturn { pub fn restore_rt() callconv(.Naked) noreturn { switch (@import("builtin").zig_backend) { - .stage2_c => asm volatile ( + .zsf_c => asm volatile ( \\ mov r7, %[number] \\ svc #0 : diff --git a/lib/std/os/linux/arm64.zig b/lib/std/os/linux/arm64.zig index b87e77430607..b5f6b1011fee 100644 --- a/lib/std/os/linux/arm64.zig +++ b/lib/std/os/linux/arm64.zig @@ -107,7 +107,7 @@ pub const restore = restore_rt; pub fn restore_rt() callconv(.Naked) noreturn { switch (@import("builtin").zig_backend) { - .stage2_c => asm volatile ( + .zsf_c => asm volatile ( \\ mov x8, %[number] \\ svc #0 : diff --git a/lib/std/os/linux/io_uring.zig b/lib/std/os/linux/io_uring.zig index fcf09b80b6cb..b5d44a5f67c0 100644 --- a/lib/std/os/linux/io_uring.zig +++ b/lib/std/os/linux/io_uring.zig @@ -1909,7 +1909,7 @@ test "openat" { const path = "test_io_uring_openat"; // Workaround for LLVM bug: https://github.com/ziglang/zig/issues/12014 - const path_addr = if (builtin.zig_backend == .stage2_llvm) p: { + const path_addr = if (builtin.zig_backend == .zsf_llvm) p: { var workaround = path; break :p @intFromPtr(workaround); } else @intFromPtr(path); diff --git a/lib/std/os/linux/x86.zig b/lib/std/os/linux/x86.zig index 721fdecb828b..6b0f9f22e700 100644 --- a/lib/std/os/linux/x86.zig +++ b/lib/std/os/linux/x86.zig @@ -125,7 +125,7 @@ pub extern fn clone(func: CloneFn, stack: usize, flags: u32, arg: usize, ptid: * pub fn restore() callconv(.Naked) noreturn { switch (@import("builtin").zig_backend) { - .stage2_c => asm volatile ( + .zsf_c => asm volatile ( \\ movl %[number], %%eax \\ int $0x80 : @@ -143,7 +143,7 @@ pub fn restore() callconv(.Naked) noreturn { pub fn restore_rt() callconv(.Naked) noreturn { switch (@import("builtin").zig_backend) { - .stage2_c => asm volatile ( + .zsf_c => asm volatile ( \\ movl %[number], %%eax \\ int $0x80 : diff --git a/lib/std/os/linux/x86_64.zig b/lib/std/os/linux/x86_64.zig index 14f9aed51bab..ba4a31540f17 100644 --- a/lib/std/os/linux/x86_64.zig +++ b/lib/std/os/linux/x86_64.zig @@ -109,7 +109,7 @@ pub const restore = restore_rt; pub fn restore_rt() callconv(.Naked) noreturn { switch (@import("builtin").zig_backend) { - .stage2_c => asm volatile ( + .zsf_c => asm volatile ( \\ movl %[number], %%eax \\ syscall : diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig index 3340087556ed..9c35876bea0b 100644 --- a/lib/std/os/windows.zig +++ b/lib/std/os/windows.zig @@ -1876,7 +1876,7 @@ extern fn zig_x86_64_windows_teb() callconv(.C) *anyopaque; pub fn teb() *TEB { return switch (native_arch) { .x86 => blk: { - if (builtin.zig_backend == .stage2_c) { + if (builtin.zig_backend == .zsf_c) { break :blk @ptrCast(@alignCast(zig_x86_windows_teb())); } else { break :blk asm volatile ( @@ -1886,7 +1886,7 @@ pub fn teb() *TEB { } }, .x86_64 => blk: { - if (builtin.zig_backend == .stage2_c) { + if (builtin.zig_backend == .zsf_c) { break :blk @ptrCast(@alignCast(zig_x86_64_windows_teb())); } else { break :blk asm volatile ( diff --git a/lib/std/rand/Xoshiro256.zig b/lib/std/rand/Xoshiro256.zig index c72d9ee1a251..3d09ffd9fdcf 100644 --- a/lib/std/rand/Xoshiro256.zig +++ b/lib/std/rand/Xoshiro256.zig @@ -90,7 +90,7 @@ pub fn fill(self: *Xoshiro256, buf: []u8) void { } test "xoroshiro sequence" { - if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest; + if (@import("builtin").zig_backend == .zsf_c) return error.SkipZigTest; var r = Xoshiro256.init(0); diff --git a/lib/std/simd.zig b/lib/std/simd.zig index 1a6b7131487a..d6fb4bcfb802 100644 --- a/lib/std/simd.zig +++ b/lib/std/simd.zig @@ -196,7 +196,7 @@ pub fn extract( } test "vector patterns" { - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .aarch64) { // https://github.com/ziglang/zig/issues/12012 return error.SkipZigTest; } @@ -428,7 +428,7 @@ test "vector prefix scan" { return error.SkipZigTest; } - if (builtin.zig_backend == .stage2_llvm) { + if (builtin.zig_backend == .zsf_llvm) { // Regressed in LLVM 14: // https://github.com/llvm/llvm-project/issues/55522 return error.SkipZigTest; diff --git a/lib/std/start.zig b/lib/std/start.zig index d2099ca8037f..f61d504ab37a 100644 --- a/lib/std/start.zig +++ b/lib/std/start.zig @@ -17,11 +17,11 @@ const start_sym_name = if (native_arch.isMIPS()) "__start" else "_start"; // Until then, we have simplified logic here for self-hosted. TODO remove this once // self-hosted is capable enough to handle all of the real start.zig logic. pub const simplified_logic = - builtin.zig_backend == .stage2_x86 or - builtin.zig_backend == .stage2_aarch64 or - builtin.zig_backend == .stage2_arm or - builtin.zig_backend == .stage2_riscv64 or - builtin.zig_backend == .stage2_sparc64 or + builtin.zig_backend == .zsf_x86 or + builtin.zig_backend == .zsf_aarch64 or + builtin.zig_backend == .zsf_arm or + builtin.zig_backend == .zsf_riscv64 or + builtin.zig_backend == .zsf_sparc64 or builtin.cpu.arch == .spirv32 or builtin.cpu.arch == .spirv64; diff --git a/lib/std/start_windows_tls.zig b/lib/std/start_windows_tls.zig index 48880b4811d3..40339786cdda 100644 --- a/lib/std/start_windows_tls.zig +++ b/lib/std/start_windows_tls.zig @@ -8,7 +8,7 @@ export var __xl_a: std.os.windows.PIMAGE_TLS_CALLBACK linksection(".CRT$XLA") = export var __xl_z: std.os.windows.PIMAGE_TLS_CALLBACK linksection(".CRT$XLZ") = null; comptime { - if (builtin.target.cpu.arch == .x86 and builtin.zig_backend != .stage2_c) { + if (builtin.target.cpu.arch == .x86 and builtin.zig_backend != .zsf_c) { // The __tls_array is the offset of the ThreadLocalStoragePointer field // in the TEB block whose base address held in the %fs segment. asm ( diff --git a/lib/std/testing.zig b/lib/std/testing.zig index 40a95a450bed..46fe424ba949 100644 --- a/lib/std/testing.zig +++ b/lib/std/testing.zig @@ -23,7 +23,7 @@ pub var log_level = std.log.Level.warn; fn print(comptime fmt: []const u8, args: anytype) void { // Disable printing in tests for simple backends. - if (builtin.zig_backend == .stage2_spirv64) return; + if (builtin.zig_backend == .zsf_spirv64) return; std.debug.print(fmt, args); } diff --git a/lib/std/zig/system/x86.zig b/lib/std/zig/system/x86.zig index b99f5cf65faa..9716527c3697 100644 --- a/lib/std/zig/system/x86.zig +++ b/lib/std/zig/system/x86.zig @@ -539,7 +539,7 @@ fn cpuid(leaf_id: u32, subid: u32) CpuidLeaf { var ecx: u32 = undefined; var edx: u32 = undefined; - if (builtin.zig_backend == .stage2_c) { + if (builtin.zig_backend == .zsf_c) { zig_x86_cpuid(leaf_id, subid, &eax, &ebx, &ecx, &edx); } else { asm volatile ("cpuid" @@ -561,7 +561,7 @@ extern fn zig_x86_get_xcr0() callconv(.C) u32; // Read control register 0 (XCR0). Used to detect features such as AVX. fn getXCR0() u32 { - if (builtin.zig_backend == .stage2_c) { + if (builtin.zig_backend == .zsf_c) { return zig_x86_get_xcr0(); } diff --git a/lib/test_runner.zig b/lib/test_runner.zig index 0b7ee24fde65..bf270da27f09 100644 --- a/lib/test_runner.zig +++ b/lib/test_runner.zig @@ -13,7 +13,7 @@ var cmdline_buffer: [4096]u8 = undefined; var fba = std.heap.FixedBufferAllocator.init(&cmdline_buffer); pub fn main() void { - if (builtin.zig_backend == .stage2_aarch64) { + if (builtin.zig_backend == .zsf_aarch64) { return mainSimple() catch @panic("test failure"); } diff --git a/src/Compilation.zig b/src/Compilation.zig index 47e13ba85c83..857096ec23ca 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -5182,18 +5182,18 @@ pub fn dump_argv(argv: []const []const u8) void { } pub fn getZigBackend(comp: Compilation) std.builtin.CompilerBackend { - if (comp.bin_file.options.use_llvm) return .stage2_llvm; + if (comp.bin_file.options.use_llvm) return .zsf_llvm; const target = comp.bin_file.options.target; - if (target.ofmt == .c) return .stage2_c; + if (target.ofmt == .c) return .zsf_c; return switch (target.cpu.arch) { - .wasm32, .wasm64 => std.builtin.CompilerBackend.stage2_wasm, - .arm, .armeb, .thumb, .thumbeb => .stage2_arm, - .x86_64 => .stage2_x86_64, - .x86 => .stage2_x86, - .aarch64, .aarch64_be, .aarch64_32 => .stage2_aarch64, - .riscv64 => .stage2_riscv64, - .sparc64 => .stage2_sparc64, - .spirv64 => .stage2_spirv64, + .wasm32, .wasm64 => .zsf_wasm, + .arm, .armeb, .thumb, .thumbeb => .zsf_arm, + .x86_64 => .zsf_x86_64, + .x86 => .zsf_x86, + .aarch64, .aarch64_be, .aarch64_32 => .zsf_aarch64, + .riscv64 => .zsf_riscv64, + .sparc64 => .zsf_sparc64, + .spirv64 => .zsf_spirv64, else => .other, }; } diff --git a/src/codegen/spirv/Section.zig b/src/codegen/spirv/Section.zig index ae88dc7c8a94..f24b7f83efed 100644 --- a/src/codegen/spirv/Section.zig +++ b/src/codegen/spirv/Section.zig @@ -372,8 +372,6 @@ test "SPIR-V Section emit() - string" { } test "SPIR-V Section emit() - extended mask" { - if (@import("builtin").zig_backend == .stage1) return error.SkipZigTest; - var section = Section{}; defer section.deinit(std.testing.allocator); diff --git a/src/target.zig b/src/target.zig index 2e7cd46e4376..dbc111705017 100644 --- a/src/target.zig +++ b/src/target.zig @@ -614,8 +614,8 @@ pub fn supportsFunctionAlignment(target: std.Target) bool { pub fn supportsTailCall(target: std.Target, backend: std.builtin.CompilerBackend) bool { switch (backend) { - .stage1, .stage2_llvm => return @import("codegen/llvm.zig").supportsTailCall(target), - .stage2_c => return true, + .zsf_llvm => return @import("codegen/llvm.zig").supportsTailCall(target), + .zsf_c => return true, else => return false, } } diff --git a/stage1/config.zig.in b/stage1/config.zig.in index 2b38d858f353..8e0a87e8169e 100644 --- a/stage1/config.zig.in +++ b/stage1/config.zig.in @@ -9,7 +9,6 @@ pub const enable_logging: bool = false; pub const enable_link_snapshots: bool = false; pub const enable_tracy = false; pub const value_tracing = false; -pub const have_stage1 = false; pub const skip_non_native = false; pub const only_c = false; pub const force_gpa = false; diff --git a/stage1/zig.h b/stage1/zig.h index 2224e71764eb..fc8995b88786 100644 --- a/stage1/zig.h +++ b/stage1/zig.h @@ -1176,10 +1176,10 @@ typedef signed __int128 zig_i128; #if zig_little_endian typedef struct { zig_align(16) uint64_t lo; uint64_t hi; } zig_u128; -typedef struct { zig_align(16) uint64_t lo; int64_t hi; } zig_i128; +typedef struct { zig_align(16) uint64_t lo; int64_t hi; } zig_i128; #else typedef struct { zig_align(16) uint64_t hi; uint64_t lo; } zig_u128; -typedef struct { zig_align(16) int64_t hi; uint64_t lo; } zig_i128; +typedef struct { zig_align(16) int64_t hi; uint64_t lo; } zig_i128; #endif #define zig_make_u128(hi, lo) ((zig_u128){ .h##i = (hi), .l##o = (lo) }) @@ -3197,11 +3197,9 @@ zig_convert_builtin(zig_compiler_rt_f16, zig_f16, trunc, zig_f64, zig_convert_builtin(zig_f16, zig_f16, trunc, zig_f80, zig_f80, 2) zig_convert_builtin(zig_f16, zig_f16, trunc, zig_f128, zig_f128, 2) zig_convert_builtin(zig_f32, zig_f32, extend, zig_compiler_rt_f16, zig_f16, 2) -zig_convert_builtin(zig_f32, zig_f32, trunc, zig_f64, zig_f64, 2) zig_convert_builtin(zig_f32, zig_f32, trunc, zig_f80, zig_f80, 2) zig_convert_builtin(zig_f32, zig_f32, trunc, zig_f128, zig_f128, 2) zig_convert_builtin(zig_f64, zig_f64, extend, zig_compiler_rt_f16, zig_f16, 2) -zig_convert_builtin(zig_f64, zig_f64, extend, zig_f32, zig_f32, 2) zig_convert_builtin(zig_f64, zig_f64, trunc, zig_f80, zig_f80, 2) zig_convert_builtin(zig_f64, zig_f64, trunc, zig_f128, zig_f128, 2) zig_convert_builtin(zig_f80, zig_f80, extend, zig_f16, zig_f16, 2) @@ -3213,6 +3211,21 @@ zig_convert_builtin(zig_f128, zig_f128, extend, zig_f32, zig_convert_builtin(zig_f128, zig_f128, extend, zig_f64, zig_f64, 2) zig_convert_builtin(zig_f128, zig_f128, extend, zig_f80, zig_f80, 2) +#ifdef __ARM_EABI__ + +zig_extern zig_callconv(pcs("aapcs")) zig_f32 __aeabi_d2f(zig_f64); +static inline zig_f32 zig_truncdfsf(zig_f64 arg) { return __aeabi_d2f(arg); } + +zig_extern zig_callconv(pcs("aapcs")) zig_f64 __aeabi_f2d(zig_f32); +static inline zig_f64 zig_extendsfdf(zig_f32 arg) { return __aeabi_f2d(arg); } + +#else /* __ARM_EABI__ */ + +zig_convert_builtin(zig_f32, zig_f32, trunc, zig_f64, zig_f64, 2) +zig_convert_builtin(zig_f64, zig_f64, extend, zig_f32, zig_f32, 2) + +#endif /* __ARM_EABI__ */ + #define zig_float_negate_builtin_0(w, c, sb) \ zig_expand_concat(zig_xor_, zig_repr_f##w)(arg, zig_make_f##w(-0x0.0p0, c sb)) #define zig_float_negate_builtin_1(w, c, sb) -arg @@ -3255,17 +3268,11 @@ zig_float_negate_builtin(128, zig_make_u128, (UINT64_C(1) << 63, UINT64_C(0))) return lhs operator rhs; \ } -#define zig_float_builtins(w) \ - zig_convert_builtin( int32_t, int32_t, fix, zig_f##w, zig_f##w, ) \ - zig_convert_builtin(uint32_t, uint32_t, fixuns, zig_f##w, zig_f##w, ) \ +#define zig_common_float_builtins(w) \ zig_convert_builtin( int64_t, int64_t, fix, zig_f##w, zig_f##w, ) \ - zig_convert_builtin(uint64_t, uint64_t, fixuns, zig_f##w, zig_f##w, ) \ zig_convert_builtin(zig_i128, zig_i128, fix, zig_f##w, zig_f##w, ) \ zig_convert_builtin(zig_u128, zig_u128, fixuns, zig_f##w, zig_f##w, ) \ - zig_convert_builtin(zig_f##w, zig_f##w, float, int32_t, int32_t, ) \ - zig_convert_builtin(zig_f##w, zig_f##w, floatun, uint32_t, uint32_t, ) \ zig_convert_builtin(zig_f##w, zig_f##w, float, int64_t, int64_t, ) \ - zig_convert_builtin(zig_f##w, zig_f##w, floatun, uint64_t, uint64_t, ) \ zig_convert_builtin(zig_f##w, zig_f##w, float, zig_i128, zig_i128, ) \ zig_convert_builtin(zig_f##w, zig_f##w, floatun, zig_u128, zig_u128, ) \ zig_expand_concat(zig_float_less_builtin_, zig_has_f##w)(f##w, cmp) \ @@ -3309,12 +3316,68 @@ zig_float_negate_builtin(128, zig_make_u128, (UINT64_C(1) << 63, UINT64_C(0))) static inline zig_f##w zig_mod_f##w(zig_f##w lhs, zig_f##w rhs) { \ return zig_sub_f##w(lhs, zig_mul_f##w(zig_div_floor_f##w(lhs, rhs), rhs)); \ } +zig_common_float_builtins(16) +zig_common_float_builtins(32) +zig_common_float_builtins(64) +zig_common_float_builtins(80) +zig_common_float_builtins(128) + +#define zig_float_builtins(w) \ + zig_convert_builtin( int32_t, int32_t, fix, zig_f##w, zig_f##w, ) \ + zig_convert_builtin(uint32_t, uint32_t, fixuns, zig_f##w, zig_f##w, ) \ + zig_convert_builtin(uint64_t, uint64_t, fixuns, zig_f##w, zig_f##w, ) \ + zig_convert_builtin(zig_f##w, zig_f##w, float, int32_t, int32_t, ) \ + zig_convert_builtin(zig_f##w, zig_f##w, floatun, uint32_t, uint32_t, ) \ + zig_convert_builtin(zig_f##w, zig_f##w, floatun, uint64_t, uint64_t, ) zig_float_builtins(16) -zig_float_builtins(32) -zig_float_builtins(64) zig_float_builtins(80) zig_float_builtins(128) +#ifdef __ARM_EABI__ + +zig_extern zig_callconv(pcs("aapcs")) int32_t __aeabi_f2iz(zig_f32); +static inline int32_t zig_fixsfsi(zig_f32 arg) { return __aeabi_f2iz(arg); } + +zig_extern zig_callconv(pcs("aapcs")) uint32_t __aeabi_f2uiz(zig_f32); +static inline uint32_t zig_fixunssfsi(zig_f32 arg) { return __aeabi_f2uiz(arg); } + +zig_extern zig_callconv(pcs("aapcs")) uint64_t __aeabi_f2ulz(zig_f32); +static inline uint64_t zig_fixunssfdi(zig_f32 arg) { return __aeabi_f2ulz(arg); } + +zig_extern zig_callconv(pcs("aapcs")) zig_f32 __aeabi_i2f(int32_t); +static inline zig_f32 zig_floatsisf(int32_t arg) { return __aeabi_i2f(arg); } + +zig_extern zig_callconv(pcs("aapcs")) zig_f32 __aeabi_ui2f(uint32_t); +static inline zig_f32 zig_floatunsisf(uint32_t arg) { return __aeabi_ui2f(arg); } + +zig_extern zig_callconv(pcs("aapcs")) zig_f32 __aeabi_ul2f(uint64_t); +static inline zig_f32 zig_floatundisf(uint64_t arg) { return __aeabi_ul2f(arg); } + +zig_extern zig_callconv(pcs("aapcs")) int32_t __aeabi_d2iz(zig_f64); +static inline int32_t zig_fixdfsi(zig_f64 arg) { return __aeabi_d2iz(arg); } + +zig_extern zig_callconv(pcs("aapcs")) uint32_t __aeabi_d2uiz(zig_f64); +static inline uint32_t zig_fixunsdfsi(zig_f64 arg) { return __aeabi_d2uiz(arg); } + +zig_extern zig_callconv(pcs("aapcs")) uint64_t __aeabi_d2ulz(zig_f64); +static inline uint64_t zig_fixunsdfdi(zig_f64 arg) { return __aeabi_d2ulz(arg); } + +zig_extern zig_callconv(pcs("aapcs")) zig_f64 __aeabi_i2d(int32_t); +static inline zig_f64 zig_floatsidf(int32_t arg) { return __aeabi_i2d(arg); } + +zig_extern zig_callconv(pcs("aapcs")) zig_f64 __aeabi_ui2d(uint32_t); +static inline zig_f64 zig_floatunsidf(uint32_t arg) { return __aeabi_ui2d(arg); } + +zig_extern zig_callconv(pcs("aapcs")) zig_f64 __aeabi_ul2d(uint64_t); +static inline zig_f64 zig_floatundidf(uint64_t arg) { return __aeabi_ul2d(arg); } + +#else /* __ARM_EABI__ */ + +zig_float_builtins(32) +zig_float_builtins(64) + +#endif /* __ARM_EABI__ */ + /* ============================ Atomics Support ============================= */ /* Note that atomics should be implemented as macros because most diff --git a/stage1/zig1.wasm b/stage1/zig1.wasm index 2a3ecafb48b4..58a8faf08ddb 100644 Binary files a/stage1/zig1.wasm and b/stage1/zig1.wasm differ diff --git a/test/behavior.zig b/test/behavior.zig index fe2856649ab4..6a6de26875b1 100644 --- a/test/behavior.zig +++ b/test/behavior.zig @@ -245,11 +245,11 @@ test { _ = @import("behavior/asm.zig"); } - if (builtin.zig_backend != .stage2_arm and - builtin.zig_backend != .stage2_x86_64 and - builtin.zig_backend != .stage2_aarch64 and - builtin.zig_backend != .stage2_c and - builtin.zig_backend != .stage2_spirv64) + if (builtin.zig_backend != .zsf_arm and + builtin.zig_backend != .zsf_x86_64 and + builtin.zig_backend != .zsf_aarch64 and + builtin.zig_backend != .zsf_c and + builtin.zig_backend != .zsf_spirv64) { _ = @import("behavior/bugs/13063.zig"); _ = @import("behavior/bugs/11227.zig"); diff --git a/test/behavior/align.zig b/test/behavior/align.zig index ee6033ede443..979bfe947fc2 100644 --- a/test/behavior/align.zig +++ b/test/behavior/align.zig @@ -16,9 +16,9 @@ test "global variable alignment" { } test "slicing array of length 1 can not assume runtime index is always zero" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var runtime_index: usize = 1; const slice = @as(*align(4) [1]u8, &foo)[runtime_index..]; @@ -61,9 +61,9 @@ test "alignment of struct with pointer has same alignment as usize" { } test "alignment and size of structs with 128-bit fields" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const A = struct { x: u128, @@ -198,7 +198,7 @@ test "alignment and size of structs with 128-bit fields" { else => return error.SkipZigTest, }; - const min_struct_align = if (builtin.zig_backend == .stage2_c) 16 else 0; + const min_struct_align = if (builtin.zig_backend == .zsf_c) 16 else 0; comptime { assert(@alignOf(A) == @max(expected.a_align, min_struct_align)); assert(@sizeOf(A) == expected.a_size); @@ -224,9 +224,9 @@ fn fnWithAlignedStack() i32 { } test "implicitly decreasing slice alignment" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a: u32 align(4) = 3; const b: u32 align(8) = 4; @@ -237,8 +237,8 @@ fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 { } test "specifying alignment allows pointer cast" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testBytesAlign(0x33); } @@ -249,10 +249,10 @@ fn testBytesAlign(b: u8) !void { } test "@alignCast slices" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var array align(4) = [_]u32{ 1, 1 }; const slice = array[0..]; @@ -267,10 +267,10 @@ fn sliceExpects4(slice: []align(4) u32) void { } test "return error union with 128-bit integer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(3 == try give()); } @@ -279,10 +279,10 @@ fn give() anyerror!u128 { } test "page aligned array on stack" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/13679 @@ -310,9 +310,9 @@ fn noop1() align(1) void {} fn noop4() align(4) void {} test "function alignment" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO // function alignment is a compile error on wasm32/wasm64 if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest; @@ -325,10 +325,10 @@ test "function alignment" { } test "implicitly decreasing fn alignment" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // function alignment is a compile error on wasm32/wasm64 if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest; @@ -349,10 +349,10 @@ fn alignedBig() align(16) i32 { } test "@alignCast functions" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // function alignment is a compile error on wasm32/wasm64 if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest; @@ -371,9 +371,9 @@ fn simple4() align(4) i32 { } test "function align expression depends on generic parameter" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO // function alignment is a compile error on wasm32/wasm64 if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest; @@ -395,8 +395,8 @@ test "function align expression depends on generic parameter" { } test "function callconv expression depends on generic parameter" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -413,8 +413,8 @@ test "function callconv expression depends on generic parameter" { } test "runtime-known array index has best alignment possible" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // take full advantage of over-alignment var array align(4) = [_]u8{ 1, 2, 3, 4 }; @@ -454,7 +454,7 @@ fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void { } test "alignment of function with c calling convention" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a = @alignOf(@TypeOf(nothing)); @@ -472,10 +472,10 @@ const DefaultAligned = struct { }; test "read 128-bit field from default aligned struct in stack memory" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var default_aligned = DefaultAligned{ .nevermind = 1, @@ -490,19 +490,19 @@ var default_aligned_global = DefaultAligned{ }; test "read 128-bit field from default aligned struct in global memory" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(12 == default_aligned_global.badguy); } test "struct field explicit alignment" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Node = struct { @@ -543,14 +543,14 @@ test "align(@alignOf(T)) T does not force resolution of T" { } test "align(N) on functions" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // This is not supported on MSVC - if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) { + if (builtin.zig_backend == .zsf_c and builtin.os.tag == .windows) { return error.SkipZigTest; } @@ -565,11 +565,11 @@ fn overaligned_fn() align(0x1000) i32 { } test "comptime alloc alignment" { - 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_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime var bytes1 = [_]u8{0}; _ = bytes1; @@ -580,9 +580,9 @@ test "comptime alloc alignment" { } test "@alignCast null" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var ptr: ?*anyopaque = null; const aligned: ?*anyopaque = @alignCast(ptr); @@ -595,11 +595,11 @@ test "alignment of slice element" { } test "sub-aligned pointer field access" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // Originally reported at https://github.com/ziglang/zig/issues/14904 diff --git a/test/behavior/array.zig b/test/behavior/array.zig index 523855161adc..b8e182e99b2e 100644 --- a/test/behavior/array.zig +++ b/test/behavior/array.zig @@ -18,10 +18,10 @@ test "array to slice" { } test "arrays" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var array: [5]u32 = undefined; @@ -47,9 +47,9 @@ fn getArrayLen(a: []const u32) usize { } test "array concat with undefined" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -71,10 +71,10 @@ test "array concat with undefined" { } test "array concat with tuple" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const array: [2]u8 = .{ 1, 2 }; { @@ -88,8 +88,8 @@ test "array concat with tuple" { } test "array init with concat" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a = 'a'; var i: [4]u8 = [2]u8{ a, 'b' } ++ [2]u8{ 'c', 'd' }; @@ -97,9 +97,9 @@ test "array init with concat" { } test "array init with mult" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a = 'a'; var i: [8]u8 = [2]u8{ a, 'b' } ** 4; @@ -110,8 +110,8 @@ test "array init with mult" { } test "array literal with explicit type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const hex_mult: [4]u16 = .{ 4096, 256, 16, 1 }; @@ -138,10 +138,10 @@ const ArrayDotLenConstExpr = struct { const some_array = [_]u8{ 0, 1, 2, 3 }; test "array literal with specified size" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var array = [2]u8{ 1, 2 }; try expect(array[0] == 1); @@ -149,7 +149,7 @@ test "array literal with specified size" { } test "array len field" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var arr = [4]u8{ 0, 0, 0, 0 }; var ptr = &arr; @@ -161,9 +161,9 @@ test "array len field" { } test "array with sentinels" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest(is_ct: bool) !void { @@ -198,10 +198,10 @@ test "void arrays" { } test "nested arrays of strings" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const array_of_strings = [_][]const u8{ "hello", "this", "is", "my", "thing" }; for (array_of_strings, 0..) |s, i| { @@ -214,8 +214,8 @@ test "nested arrays of strings" { } test "nested arrays of integers" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const array_of_numbers = [_][2]u8{ [2]u8{ 1, 2 }, @@ -229,9 +229,9 @@ test "nested arrays of integers" { } test "implicit comptime in array type size" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var arr: [plusOne(10)]bool = undefined; try expect(arr.len == 11); @@ -242,9 +242,9 @@ fn plusOne(x: u32) u32 { } test "single-item pointer to array indexing and slicing" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testSingleItemPtrArrayIndexSlice(); try comptime testSingleItemPtrArrayIndexSlice(); @@ -269,8 +269,8 @@ fn doSomeMangling(array: *[4]u8) void { } test "implicit cast zero sized array ptr to slice" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var b = "".*; @@ -285,10 +285,10 @@ test "implicit cast zero sized array ptr to slice" { } test "anonymous list literal syntax" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -307,9 +307,9 @@ var s_array: [8]Sub = undefined; const Sub = struct { b: u8 }; const Str = struct { a: []Sub }; test "set global var array via slice embedded in struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var s = Str{ .a = s_array[0..] }; @@ -323,10 +323,10 @@ test "set global var array via slice embedded in struct" { } test "read/write through global variable array of struct fields initialized via array mult" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -345,8 +345,8 @@ test "read/write through global variable array of struct fields initialized via } test "implicit cast single-item pointer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testImplicitCastSingleItemPtr(); try comptime testImplicitCastSingleItemPtr(); @@ -364,9 +364,9 @@ fn testArrayByValAtComptime(b: [2]u8) u8 { } test "comptime evaluating function that takes array by value" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const arr = [_]u8{ 1, 2 }; const x = comptime testArrayByValAtComptime(arr); @@ -376,9 +376,9 @@ test "comptime evaluating function that takes array by value" { } test "runtime initialize array elem and then implicit cast to slice" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var two: i32 = 2; const x: []const i32 = &[_]i32{two}; @@ -386,9 +386,9 @@ test "runtime initialize array elem and then implicit cast to slice" { } test "array literal as argument to function" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn entry(two: i32) !void { @@ -414,10 +414,10 @@ test "array literal as argument to function" { } test "double nested array to const slice cast in array literal" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn entry(two: i32) !void { @@ -476,10 +476,10 @@ test "double nested array to const slice cast in array literal" { } test "anonymous literal in array" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Foo = struct { @@ -502,9 +502,9 @@ test "anonymous literal in array" { } test "access the null element of a null terminated array" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -519,10 +519,10 @@ test "access the null element of a null terminated array" { } test "type deduction for array subscript expression" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -538,9 +538,9 @@ test "type deduction for array subscript expression" { } test "sentinel element count towards the ABI size calculation" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -562,9 +562,9 @@ test "sentinel element count towards the ABI size calculation" { } test "zero-sized array with recursive type definition" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = struct { fn foo(comptime T: type, comptime n: usize) type { @@ -584,10 +584,10 @@ test "zero-sized array with recursive type definition" { } test "type coercion of anon struct literal to array" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const U = union { @@ -617,10 +617,10 @@ test "type coercion of anon struct literal to array" { } test "type coercion of pointer to anon struct literal to pointer to array" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const U = union { @@ -656,10 +656,10 @@ test "array with comptime-only element type" { } test "tuple to array handles sentinel" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const a = .{ 1, 2, 3 }; @@ -669,10 +669,10 @@ test "tuple to array handles sentinel" { } test "array init of container level array variable" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { var pair: [2]usize = .{ 1, 2 }; @@ -700,10 +700,10 @@ test "runtime initialized sentinel-terminated array literal" { } test "array of array agregate init" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a = [1]u32{11} ** 10; var b = [1][10]u32{a} ** 2; @@ -750,10 +750,10 @@ test "array init with no result location has result type" { } test "slicing array of zero-sized values" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var arr: [32]u0 = undefined; for (arr[0..]) |*zero| diff --git a/test/behavior/asm.zig b/test/behavior/asm.zig index fb08020ff31b..363c975ee78a 100644 --- a/test/behavior/asm.zig +++ b/test/behavior/asm.zig @@ -6,9 +6,9 @@ const expectEqual = std.testing.expectEqual; const is_x86_64_linux = builtin.cpu.arch == .x86_64 and builtin.os.tag == .linux; comptime { - if (builtin.zig_backend != .stage2_arm and - builtin.zig_backend != .stage2_aarch64 and - !(builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) and // MSVC doesn't support inline assembly + if (builtin.zig_backend != .zsf_arm and + builtin.zig_backend != .zsf_aarch64 and + !(builtin.zig_backend == .zsf_c and builtin.os.tag == .windows) and // MSVC doesn't support inline assembly is_x86_64_linux) { asm ( @@ -19,7 +19,7 @@ comptime { \\.type this_is_my_alias, @function; \\.set this_is_my_alias, derp; ); - } else if (builtin.zig_backend == .stage2_spirv64) { + } else if (builtin.zig_backend == .zsf_spirv64) { asm ( \\%a = OpString "hello there" ); @@ -27,13 +27,13 @@ comptime { } test "module level assembly" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly + if (builtin.zig_backend == .zsf_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly if (is_x86_64_linux) { try expect(this_is_my_alias() == 1234); @@ -41,14 +41,14 @@ test "module level assembly" { } test "output constraint modifiers" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly + if (builtin.zig_backend == .zsf_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly // This is only testing compilation. var a: u32 = 3; @@ -65,14 +65,14 @@ test "output constraint modifiers" { } test "alternative constraints" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly + if (builtin.zig_backend == .zsf_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly // Make sure we allow commas as a separator for alternative constraints. var a: u32 = 3; @@ -84,14 +84,14 @@ test "alternative constraints" { } test "sized integer/float in asm input" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly + if (builtin.zig_backend == .zsf_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly asm volatile ("" : @@ -136,13 +136,13 @@ test "sized integer/float in asm input" { } test "struct/array/union types as input values" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly + if (builtin.zig_backend == .zsf_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly asm volatile ("" : @@ -165,7 +165,7 @@ export fn derp() i32 { } test "rw constraint (x86_64)" { - if (builtin.target.cpu.arch != .x86_64 or builtin.zig_backend != .stage2_llvm) + if (builtin.target.cpu.arch != .x86_64 or builtin.zig_backend != .zsf_llvm) return error.SkipZigTest; var res: i32 = 5; @@ -179,9 +179,9 @@ test "rw constraint (x86_64)" { test "asm modifiers (AArch64)" { if (builtin.target.cpu.arch != .aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly + if (builtin.zig_backend == .zsf_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly var x: u32 = 15; const double = asm ("add %[ret:w], %[in:w], %[in:w]" diff --git a/test/behavior/atomics.zig b/test/behavior/atomics.zig index 5264ef75cf5e..ec1b6a604381 100644 --- a/test/behavior/atomics.zig +++ b/test/behavior/atomics.zig @@ -11,10 +11,10 @@ const supports_128_bit_atomics = switch (builtin.cpu.arch) { }; test "cmpxchg" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testCmpxchg(); try comptime testCmpxchg(); @@ -38,9 +38,9 @@ fn testCmpxchg() !void { } test "fence" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: i32 = 1234; @fence(.SeqCst); @@ -48,10 +48,10 @@ test "fence" { } test "atomicrmw and atomicload" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var data: u8 = 200; try testAtomicRmw(&data); @@ -76,10 +76,10 @@ fn testAtomicLoad(ptr: *u8) !void { } test "cmpxchg with ptr" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var data1: i32 = 1234; var data2: i32 = 5678; @@ -101,10 +101,10 @@ test "cmpxchg with ptr" { } test "cmpxchg with ignored result" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: i32 = 1234; @@ -116,10 +116,10 @@ test "cmpxchg with ignored result" { test "128-bit cmpxchg" { if (!supports_128_bit_atomics) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO try test_u128_cmpxchg(); try comptime test_u128_cmpxchg(); @@ -145,12 +145,12 @@ fn test_u128_cmpxchg() !void { var a_global_variable = @as(u32, 1234); test "cmpxchg on a global variable" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .aarch64) { // https://github.com/ziglang/zig/issues/10627 return error.SkipZigTest; } @@ -160,10 +160,10 @@ test "cmpxchg on a global variable" { } test "atomic load and rmw with enum" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Value = enum(u8) { a, b, c }; var x = Value.a; @@ -177,10 +177,10 @@ test "atomic load and rmw with enum" { } test "atomic store" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u32 = 0; @atomicStore(u32, &x, 1, .SeqCst); @@ -190,10 +190,10 @@ test "atomic store" { } test "atomic store comptime" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testAtomicStore(); try testAtomicStore(); @@ -208,13 +208,13 @@ fn testAtomicStore() !void { } test "atomicrmw with floats" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .aarch64) { // https://github.com/ziglang/zig/issues/10627 return error.SkipZigTest; } @@ -238,10 +238,10 @@ fn testAtomicRmwFloat() !void { } test "atomicrmw with ints" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testAtomicRmwInts(); try comptime testAtomicRmwInts(); @@ -310,11 +310,11 @@ fn testAtomicRmwInt(comptime signedness: std.builtin.Signedness, comptime N: usi test "atomicrmw with 128-bit ints" { if (!supports_128_bit_atomics) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO // TODO "ld.lld: undefined symbol: __sync_lock_test_and_set_16" on -mcpu x86_64 - if (builtin.cpu.arch == .x86_64 and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; + if (builtin.cpu.arch == .x86_64 and builtin.zig_backend == .zsf_llvm) return error.SkipZigTest; try testAtomicRmwInt128(.signed); try testAtomicRmwInt128(.unsigned); @@ -383,10 +383,10 @@ fn testAtomicRmwInt128(comptime signedness: std.builtin.Signedness) !void { } test "atomics with different types" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testAtomicsWithType(bool, true, false); @@ -412,10 +412,10 @@ fn testAtomicsWithType(comptime T: type, a: T, b: T) !void { } test "return @atomicStore, using it as a void value" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const A = struct { diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 57a579cfdb27..74c5a6a1b7f2 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -24,7 +24,7 @@ fn testTruncate(x: u32) u8 { } test "truncate to non-power-of-two integers" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testTrunc(u32, u1, 0b10101, 0b1); try testTrunc(u32, u1, 0b10110, 0b0); @@ -38,11 +38,11 @@ test "truncate to non-power-of-two integers" { } test "truncate to non-power-of-two integers from 128-bit" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testTrunc(u128, u1, 0xffffffff_ffffffff_ffffffff_01010101, 0x01); try testTrunc(u128, u1, 0xffffffff_ffffffff_ffffffff_01010110, 0x00); @@ -63,7 +63,7 @@ const g1: i32 = 1233 + 1; var g2: i32 = 0; test "global variables" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(g2 == 0); g2 = g1; @@ -131,19 +131,19 @@ fn first4KeysOfHomeRow() []const u8 { } test "return string from function" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu")); } test "hex escape" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello")); } test "multiline string" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const s1 = \\one @@ -155,7 +155,7 @@ test "multiline string" { } test "multiline string comments at start" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const s1 = //\\one @@ -167,7 +167,7 @@ test "multiline string comments at start" { } test "multiline string comments at end" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const s1 = \\one @@ -179,7 +179,7 @@ test "multiline string comments at end" { } test "multiline string comments in middle" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const s1 = \\one @@ -191,7 +191,7 @@ test "multiline string comments in middle" { } test "multiline string comments at multiple places" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const s1 = \\one @@ -209,7 +209,7 @@ test "string concatenation simple" { } test "array mult operator" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(mem.eql(u8, "ab" ** 5, "ababababab")); } @@ -218,8 +218,8 @@ const OpaqueA = opaque {}; const OpaqueB = opaque {}; test "opaque types" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(*OpaqueA != *OpaqueB); @@ -236,7 +236,7 @@ test "compile time global reinterpret" { } test "cast undefined" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const array: [100]u8 = undefined; const slice = @as([]const u8, &array); @@ -247,8 +247,8 @@ fn testCastUndefined(x: []const u8) void { } test "implicit cast after unreachable" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(outer() == 1234); } @@ -305,8 +305,8 @@ fn fB() []const u8 { } test "call function pointer in struct" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, f3(true), "a")); try expect(mem.eql(u8, f3(false), "b")); @@ -329,8 +329,8 @@ const FnPtrWrapper = struct { }; test "const ptr from var variable" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u64 = undefined; var y: u64 = undefined; @@ -346,10 +346,10 @@ fn copy(src: *const u64, dst: *u64) void { } test "call result of if else expression" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, f2(true), "a")); try expect(mem.eql(u8, f2(false), "b")); @@ -359,7 +359,7 @@ fn f2(x: bool) []const u8 { } test "variable is allowed to be a pointer to an opaque type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: i32 = 1234; _ = hereIsAnOpaqueType(@as(*OpaqueA, @ptrCast(&x))); @@ -370,9 +370,9 @@ fn hereIsAnOpaqueType(ptr: *OpaqueA) *OpaqueA { } test "take address of parameter" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testTakeAddressOfParameter(12.34); } @@ -382,7 +382,7 @@ fn testTakeAddressOfParameter(f: f32) !void { } test "pointer to void return type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testPointerToVoidReturnType(); } @@ -396,11 +396,11 @@ fn testPointerToVoidReturnType2() *const void { } test "array 2D const double ptr" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const rect_2d_vertexes = [_][1]f32{ [_]f32{1.0}, @@ -410,10 +410,10 @@ test "array 2D const double ptr" { } test "array 2D const double ptr with offset" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const rect_2d_vertexes = [_][2]f32{ [_]f32{ 3.0, 4.239 }, @@ -423,10 +423,10 @@ test "array 2D const double ptr with offset" { } test "array 3D const double ptr with offset" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const rect_3d_vertexes = [_][2][2]f32{ [_][2]f32{ @@ -448,7 +448,7 @@ fn testArray2DConstDoublePtr(ptr: *const f32) !void { } test "double implicit cast in same expression" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var x = @as(i32, @as(u16, nine())); try expect(x == 9); @@ -458,8 +458,8 @@ fn nine() u8 { } test "struct inside function" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testStructInFn(); try comptime testStructInFn(); @@ -480,8 +480,8 @@ fn testStructInFn() !void { } test "fn call returning scalar optional in equality expression" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(getNull() == null); } @@ -490,9 +490,9 @@ fn getNull() ?*i32 { } test "global variable assignment with optional unwrapping with var initialized to undefined" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { var data: i32 = 1234; @@ -509,8 +509,8 @@ test "global variable assignment with optional unwrapping with var initialized t var global_foo: *i32 = undefined; test "peer result location with typed parent, runtime condition, comptime prongs" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest(arg: i32) i32 { @@ -581,14 +581,14 @@ test "comptime cast fn to ptr" { } test "equality compare fn ptrs" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // Test passes but should not + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // Test passes but should not var a = &emptyFn; try expect(a == a); } test "self reference through fn ptr field" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const A = struct { @@ -606,8 +606,8 @@ test "self reference through fn ptr field" { } test "global variable initialized to global variable array element" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(global_ptr == &gdt[0]); } @@ -621,7 +621,7 @@ var gdt = [_]GDTEntry{ var global_ptr = &gdt[0]; test "global constant is loaded with a runtime-known index" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -638,8 +638,8 @@ test "global constant is loaded with a runtime-known index" { } test "multiline string literal is null terminated" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const s1 = \\one @@ -651,10 +651,10 @@ test "multiline string literal is null terminated" { } test "string escapes" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqualStrings("\"", "\x22"); try expectEqualStrings("\'", "\x27"); @@ -681,9 +681,9 @@ fn ptrEql(a: *const []const u8, b: *const []const u8) bool { } test "string concatenation" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const a = "OK" ++ " IT " ++ "WORKED"; const b = "OK IT WORKED"; @@ -708,10 +708,10 @@ fn manyptrConcat(comptime s: [*:0]const u8) [*:0]const u8 { } test "comptime manyptr concatenation" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const s = "epic"; const actual = manyptrConcat(s); @@ -730,10 +730,10 @@ test "comptime manyptr concatenation" { } test "result location is optional inside error union" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const x = maybe(true) catch unreachable; try expect(x.? == 42); @@ -747,8 +747,8 @@ fn maybe(x: bool) anyerror!?u32 { } test "auto created variables have correct alignment" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn foo(str: [*]const u8) u32 { @@ -763,13 +763,13 @@ test "auto created variables have correct alignment" { } test "extern variable with non-pointer opaque type" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; @export(var_to_export, .{ .name = "opaque_extern_var" }); try expect(@as(*align(1) u32, @ptrCast(&opaque_extern_var)).* == 42); @@ -809,9 +809,9 @@ test "if expression type coercion" { } test "discarding the result of various expressions" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn foo() !u32 { @@ -850,9 +850,9 @@ test "labeled block implicitly ends in a break" { } test "catch in block has correct result location" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn open() error{A}!@This() { @@ -882,7 +882,7 @@ test "labeled block with runtime branch forwards its result location type to bre } test "try in labeled block doesn't cast to wrong type" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { a: u32, @@ -907,9 +907,9 @@ test "vector initialized with array init syntax has proper type" { } test "weird array and tuple initializations" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const E = enum { a, b }; const S = struct { e: E }; @@ -952,7 +952,7 @@ test "generic function uses return type of other generic function" { // https://github.com/ziglang/zig/issues/12208 return error.SkipZigTest; } - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO const S = struct { fn call( @@ -1026,8 +1026,8 @@ comptime { } test "switch inside @as gets correct type" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: u32 = 0; var b: [2]u32 = undefined; @@ -1050,11 +1050,11 @@ test "inline call of function with a switch inside the return statement" { } test "namespace lookup ignores decl causing the lookup" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_llvm) { + if (builtin.zig_backend == .zsf_llvm) { // regressed with LLVM 15 // https://github.com/ziglang/zig/issues/12681 return error.SkipZigTest; @@ -1118,8 +1118,8 @@ test "returning an opaque type from a function" { } test "orelse coercion as function argument" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO const Loc = struct { start: i32 = -1 }; const Container = struct { @@ -1136,7 +1136,7 @@ test "orelse coercion as function argument" { } test "runtime-known globals initialized with undefined" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { var array: [10]u32 = [_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; @@ -1152,12 +1152,12 @@ test "runtime-known globals initialized with undefined" { } test "arrays and vectors with big integers" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO: only aarch64-windows didn't pass in the PR that added this code. // figure out why if you can run this target. diff --git a/test/behavior/bit_shifting.zig b/test/behavior/bit_shifting.zig index 8b605385d2cf..e4f9693723d3 100644 --- a/test/behavior/bit_shifting.zig +++ b/test/behavior/bit_shifting.zig @@ -61,10 +61,10 @@ fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, compt } test "sharded table" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // realistic 16-way sharding try testShardedTable(u32, 4, 8); diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig index 3833fe1b31c3..2065cf2dff1f 100644 --- a/test/behavior/bitcast.zig +++ b/test/behavior/bitcast.zig @@ -8,7 +8,7 @@ const minInt = std.math.minInt; const native_endian = builtin.target.cpu.arch.endian(); test "@bitCast iX -> uX (32, 64)" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; const bit_values = [_]usize{ 32, 64 }; @@ -19,10 +19,10 @@ test "@bitCast iX -> uX (32, 64)" { } test "@bitCast iX -> uX (8, 16, 128)" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const bit_values = [_]usize{ 8, 16, 128 }; @@ -33,11 +33,11 @@ test "@bitCast iX -> uX (8, 16, 128)" { } test "@bitCast iX -> uX exotic integers" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 }; @@ -79,11 +79,11 @@ fn conv_uN(comptime N: usize, x: std.meta.Int(.unsigned, N)) std.meta.Int(.signe } test "bitcast uX to bytes" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 }; inline for (bit_values) |bits| { @@ -151,7 +151,7 @@ test "bitcast literal [4]u8 param to u32" { } test "bitcast generates a temporary value" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var y = @as(u16, 0x55AA); const x = @as(u16, @bitCast(@as([2]u8, @bitCast(y)))); @@ -159,10 +159,10 @@ test "bitcast generates a temporary value" { } test "@bitCast packed structs at runtime and comptime" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Full = packed struct { number: u16, @@ -186,9 +186,9 @@ test "@bitCast packed structs at runtime and comptime" { } test "@bitCast extern structs at runtime and comptime" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Full = extern struct { number: u16, @@ -218,10 +218,10 @@ test "@bitCast extern structs at runtime and comptime" { } test "bitcast packed struct to integer and back" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const LevelUpMove = packed struct { move_id: u9, @@ -241,9 +241,9 @@ test "bitcast packed struct to integer and back" { } test "implicit cast to error union by returning" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn entry() !void { @@ -293,13 +293,13 @@ test "triple level result location with bitcast sandwich passed as tuple element } test "@bitCast packed struct of floats" { - 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_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Foo = packed struct { a: f16 = 0, @@ -330,15 +330,15 @@ test "@bitCast packed struct of floats" { } test "comptime @bitCast packed struct to int and back" { - 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_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - - if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) { + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + + if (builtin.zig_backend == .zsf_llvm and native_endian == .Big) { // https://github.com/ziglang/zig/issues/13782 return error.SkipZigTest; } @@ -372,12 +372,12 @@ test "comptime @bitCast packed struct to int and back" { } test "comptime bitcast with fields following f80" { - if (builtin.zig_backend == .stage2_wasm) 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; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const FloatT = extern struct { f: f80, x: u128 align(16) }; const x: FloatT = .{ .f = 0.5, .x = 123 }; @@ -388,12 +388,12 @@ test "comptime bitcast with fields following f80" { } test "bitcast vector to integer and back" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c) 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 - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const arr: [16]bool = [_]bool{ true, false } ++ [_]bool{true} ** 14; var x: @Vector(16, bool) = @splat(true); @@ -414,14 +414,14 @@ fn bitCastWrapper128(x: f128) u128 { return @as(u128, @bitCast(x)); } test "bitcast nan float does modify signaling bit" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c) 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 - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO: https://github.com/ziglang/zig/issues/14366 - if (builtin.zig_backend == .stage2_llvm and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_llvm and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; // 16 bit const snan_f16_const = math.nan_f16; @@ -461,12 +461,12 @@ test "bitcast nan float does modify signaling bit" { } test "@bitCast of packed struct of bools all true" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c) 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 - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const P = packed struct { b0: bool, @@ -483,12 +483,12 @@ test "@bitCast of packed struct of bools all true" { } test "@bitCast of packed struct of bools all false" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c) 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 - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const P = packed struct { b0: bool, diff --git a/test/behavior/bitreverse.zig b/test/behavior/bitreverse.zig index 722edef25ebf..30208fc5b0b6 100644 --- a/test/behavior/bitreverse.zig +++ b/test/behavior/bitreverse.zig @@ -4,18 +4,18 @@ const expect = std.testing.expect; const minInt = std.math.minInt; test "@bitReverse large exotic integer" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; try expect(@bitReverse(@as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624); } test "@bitReverse" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - 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; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testBitReverse(); try testBitReverse(); @@ -96,12 +96,12 @@ fn vector8() !void { } test "bitReverse vectors u8" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - 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; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime vector8(); try vector8(); @@ -115,12 +115,12 @@ fn vector16() !void { } test "bitReverse vectors u16" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - 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; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime vector16(); try vector16(); @@ -134,12 +134,12 @@ fn vector24() !void { } test "bitReverse vectors u24" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - 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; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime vector24(); try vector24(); @@ -153,7 +153,7 @@ fn vector0() !void { } test "bitReverse vectors u0" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; try comptime vector0(); try vector0(); diff --git a/test/behavior/bool.zig b/test/behavior/bool.zig index 5d09e5f8a00d..e11d25459c29 100644 --- a/test/behavior/bool.zig +++ b/test/behavior/bool.zig @@ -9,7 +9,7 @@ test "bool literals" { } test "cast bool to int" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const t = true; const f = false; diff --git a/test/behavior/bugs/10138.zig b/test/behavior/bugs/10138.zig index 1c8ff7cf7c4c..f2af860149ff 100644 --- a/test/behavior/bugs/10138.zig +++ b/test/behavior/bugs/10138.zig @@ -2,10 +2,10 @@ const std = @import("std"); const builtin = @import("builtin"); test "registers get overwritten when ignoring return" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; if (builtin.cpu.arch != .x86_64 or builtin.os.tag != .linux) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const fd = open(); _ = write(fd, "a", 1); diff --git a/test/behavior/bugs/10147.zig b/test/behavior/bugs/10147.zig index a1fe9bff6830..dc1d12cf247f 100644 --- a/test/behavior/bugs/10147.zig +++ b/test/behavior/bugs/10147.zig @@ -2,12 +2,12 @@ const builtin = @import("builtin"); const std = @import("std"); test "test calling @clz on both vector and scalar inputs" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u32 = 0x1; var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 }; diff --git a/test/behavior/bugs/10684.zig b/test/behavior/bugs/10684.zig index e7033eec8f80..e287c72c6faf 100644 --- a/test/behavior/bugs/10684.zig +++ b/test/behavior/bugs/10684.zig @@ -3,11 +3,11 @@ const builtin = @import("builtin"); const expectEqualStrings = std.testing.expectEqualStrings; test "slicing slices" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const foo = "1234"; const bar = foo[0..4]; diff --git a/test/behavior/bugs/1076.zig b/test/behavior/bugs/1076.zig index 9aca002c901f..53b6578ed531 100644 --- a/test/behavior/bugs/1076.zig +++ b/test/behavior/bugs/1076.zig @@ -4,9 +4,9 @@ const mem = std.mem; const expect = std.testing.expect; test "comptime code should not modify constant data" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testCastPtrOfArrayToSliceAndPtr(); try comptime testCastPtrOfArrayToSliceAndPtr(); diff --git a/test/behavior/bugs/10970.zig b/test/behavior/bugs/10970.zig index 008242196c63..fada42fb1a1f 100644 --- a/test/behavior/bugs/10970.zig +++ b/test/behavior/bugs/10970.zig @@ -4,10 +4,10 @@ fn retOpt() ?u32 { return null; } test "breaking from a loop in an if statement" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var cond = true; const opt = while (cond) { diff --git a/test/behavior/bugs/11046.zig b/test/behavior/bugs/11046.zig index 6bf6041a65c9..8dea32dd13e8 100644 --- a/test/behavior/bugs/11046.zig +++ b/test/behavior/bugs/11046.zig @@ -10,10 +10,10 @@ fn bar() !void { } test "fixed" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; bar() catch |err| switch (err) { error.Foo => {}, // error: expected (inferred error set of bar), found error{Foo} diff --git a/test/behavior/bugs/11100.zig b/test/behavior/bugs/11100.zig index 1a55b945106f..d84b1792aa4c 100644 --- a/test/behavior/bugs/11100.zig +++ b/test/behavior/bugs/11100.zig @@ -9,7 +9,7 @@ pub fn do() bool { } test "bug" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try std.testing.expect(!do()); } diff --git a/test/behavior/bugs/11139.zig b/test/behavior/bugs/11139.zig index 85b2e6957bbe..250db1d3bea1 100644 --- a/test/behavior/bugs/11139.zig +++ b/test/behavior/bugs/11139.zig @@ -3,10 +3,10 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test "store array of array of structs at comptime" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(storeArrayOfArrayOfStructs() == 15); try comptime expect(storeArrayOfArrayOfStructs() == 15); diff --git a/test/behavior/bugs/11165.zig b/test/behavior/bugs/11165.zig index 129b605100af..dd92ab347487 100644 --- a/test/behavior/bugs/11165.zig +++ b/test/behavior/bugs/11165.zig @@ -1,8 +1,8 @@ const builtin = @import("builtin"); test "bytes" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { a: u32, @@ -23,8 +23,8 @@ test "bytes" { } test "aggregate" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { a: u32, diff --git a/test/behavior/bugs/11181.zig b/test/behavior/bugs/11181.zig index 8abccc40c3a6..2994b56bb1da 100644 --- a/test/behavior/bugs/11181.zig +++ b/test/behavior/bugs/11181.zig @@ -12,7 +12,7 @@ test "const inferred array of slices" { } test "var inferred array of slices" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const T = struct { v: bool }; diff --git a/test/behavior/bugs/11213.zig b/test/behavior/bugs/11213.zig index 875c12697b02..5aae553092ad 100644 --- a/test/behavior/bugs/11213.zig +++ b/test/behavior/bugs/11213.zig @@ -3,7 +3,7 @@ const builtin = @import("builtin"); const testing = std.testing; test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const g: error{Test}!void = error.Test; diff --git a/test/behavior/bugs/11787.zig b/test/behavior/bugs/11787.zig index 47af7a350a04..734ba328c07e 100644 --- a/test/behavior/bugs/11787.zig +++ b/test/behavior/bugs/11787.zig @@ -3,11 +3,11 @@ const builtin = @import("builtin"); const testing = std.testing; test "slicing zero length array field of struct" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { a: [0]usize, diff --git a/test/behavior/bugs/11816.zig b/test/behavior/bugs/11816.zig index 6061d668f316..ab7a79aa20c8 100644 --- a/test/behavior/bugs/11816.zig +++ b/test/behavior/bugs/11816.zig @@ -2,9 +2,9 @@ const std = @import("std"); const builtin = @import("builtin"); test { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u32 = 3; const val: usize = while (true) switch (x) { diff --git a/test/behavior/bugs/11995.zig b/test/behavior/bugs/11995.zig index fe554bc4bf6c..45d0eb1f8ee9 100644 --- a/test/behavior/bugs/11995.zig +++ b/test/behavior/bugs/11995.zig @@ -17,12 +17,12 @@ const wuffs_base__slice_u8 = extern struct { len: usize, }; test { - 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_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var string: [5]u8 = "hello".*; const arg_data = wuffs_base__slice_u8{ .ptr = @as([*c]u8, @ptrCast(&string)), .len = string.len }; diff --git a/test/behavior/bugs/12000.zig b/test/behavior/bugs/12000.zig index 808ca061b8a8..8a4f2dffc40f 100644 --- a/test/behavior/bugs/12000.zig +++ b/test/behavior/bugs/12000.zig @@ -6,11 +6,11 @@ const T = struct { }; test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var t: T = .{ .next = null }; try std.testing.expect(t.next == null); diff --git a/test/behavior/bugs/12025.zig b/test/behavior/bugs/12025.zig index aa293aa6b51e..de5bf7906030 100644 --- a/test/behavior/bugs/12025.zig +++ b/test/behavior/bugs/12025.zig @@ -1,7 +1,7 @@ const builtin = @import("builtin"); test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime var st = .{ .foo = &1, diff --git a/test/behavior/bugs/12033.zig b/test/behavior/bugs/12033.zig index dfe583f156b2..bb97c28bc193 100644 --- a/test/behavior/bugs/12033.zig +++ b/test/behavior/bugs/12033.zig @@ -2,7 +2,7 @@ const std = @import("std"); const builtin = @import("builtin"); test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const string = "Hello!\x00World!"; try std.testing.expect(@TypeOf(string) == *const [13:0]u8); diff --git a/test/behavior/bugs/12043.zig b/test/behavior/bugs/12043.zig index 835b2f6b4ec8..7616be64ab04 100644 --- a/test/behavior/bugs/12043.zig +++ b/test/behavior/bugs/12043.zig @@ -7,7 +7,7 @@ fn foo(x: anytype) void { ok = x; } test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const x = &foo; x(true); diff --git a/test/behavior/bugs/12051.zig b/test/behavior/bugs/12051.zig index 342e851b775a..26e23bf6dbbf 100644 --- a/test/behavior/bugs/12051.zig +++ b/test/behavior/bugs/12051.zig @@ -2,12 +2,12 @@ const std = @import("std"); const builtin = @import("builtin"); test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const x = X{}; try std.testing.expectEqual(@as(u16, 0), x.y.a); diff --git a/test/behavior/bugs/12092.zig b/test/behavior/bugs/12092.zig index 434da854f89d..516b425a6bed 100644 --- a/test/behavior/bugs/12092.zig +++ b/test/behavior/bugs/12092.zig @@ -14,11 +14,11 @@ fn takeFoo(foo: *const Foo) !void { } test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var baz: u32 = 24; try takeFoo(&.{ diff --git a/test/behavior/bugs/12119.zig b/test/behavior/bugs/12119.zig index 6cfb015eb0a3..bd600eed9af8 100644 --- a/test/behavior/bugs/12119.zig +++ b/test/behavior/bugs/12119.zig @@ -5,11 +5,11 @@ const u8x32 = @Vector(32, u8); const u32x8 = @Vector(8, u32); test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const zerox32: u8x32 = [_]u8{0} ** 32; const bigsum: u32x8 = @as(u32x8, @bitCast(zerox32)); diff --git a/test/behavior/bugs/12142.zig b/test/behavior/bugs/12142.zig index ca66b1f8f5b9..57bd01273fba 100644 --- a/test/behavior/bugs/12142.zig +++ b/test/behavior/bugs/12142.zig @@ -19,10 +19,10 @@ fn letter(e: Letter) u8 { } test { - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const test_struct = Test{ .holders = &.{ diff --git a/test/behavior/bugs/12169.zig b/test/behavior/bugs/12169.zig index b3db56e20bb6..1a8add406f05 100644 --- a/test/behavior/bugs/12169.zig +++ b/test/behavior/bugs/12169.zig @@ -2,12 +2,12 @@ const std = @import("std"); const builtin = @import("builtin"); test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO - if (comptime builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.endian() == .Big) { + if (comptime builtin.zig_backend == .zsf_llvm and builtin.cpu.arch.endian() == .Big) { // https://github.com/ziglang/zig/issues/13782 return error.SkipZigTest; } diff --git a/test/behavior/bugs/12450.zig b/test/behavior/bugs/12450.zig index 5ab6565f3c9e..4f4ceb060984 100644 --- a/test/behavior/bugs/12450.zig +++ b/test/behavior/bugs/12450.zig @@ -9,12 +9,12 @@ const Foo = packed struct { var buffer: [256]u8 = undefined; test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var f1: *align(16) Foo = @alignCast(@as(*align(1) Foo, @ptrCast(&buffer[0]))); try expect(@typeInfo(@TypeOf(f1)).Pointer.alignment == 16); diff --git a/test/behavior/bugs/12551.zig b/test/behavior/bugs/12551.zig index b2a79c084755..2eff50b89a01 100644 --- a/test/behavior/bugs/12551.zig +++ b/test/behavior/bugs/12551.zig @@ -2,9 +2,9 @@ const std = @import("std"); const builtin = @import("builtin"); test { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try std.testing.expect(for ([1]u8{0}) |x| { if (x == 0) break true; diff --git a/test/behavior/bugs/12571.zig b/test/behavior/bugs/12571.zig index f474c3282438..50ac30b66d59 100644 --- a/test/behavior/bugs/12571.zig +++ b/test/behavior/bugs/12571.zig @@ -12,9 +12,9 @@ const Entry = packed struct { }; test { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const frame = Frame{ .num = 0x7FDE }; var entry = Entry{ .other = 0, .frame = .{ .num = 0xFFFFF } }; diff --git a/test/behavior/bugs/12644.zig b/test/behavior/bugs/12644.zig index 3c0cc5656f2f..c464ebf5d441 100644 --- a/test/behavior/bugs/12644.zig +++ b/test/behavior/bugs/12644.zig @@ -10,7 +10,7 @@ fn main0() !void { } test "issue12644" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; main0() catch |e| { try std.testing.expect(e == error.AnError); diff --git a/test/behavior/bugs/12680.zig b/test/behavior/bugs/12680.zig index b86a015e6870..bae050895772 100644 --- a/test/behavior/bugs/12680.zig +++ b/test/behavior/bugs/12680.zig @@ -6,13 +6,13 @@ const builtin = @import("builtin"); extern fn test_func() callconv(.C) usize; test "export a function twice" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.os.tag == .macos and builtin.zig_backend == .stage2_c) { + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.os.tag == .macos and builtin.zig_backend == .zsf_c) { // TODO: test.c: error: aliases are not supported on darwin return error.SkipZigTest; } diff --git a/test/behavior/bugs/1277.zig b/test/behavior/bugs/1277.zig index d5312a378eee..2788c29fa89a 100644 --- a/test/behavior/bugs/1277.zig +++ b/test/behavior/bugs/1277.zig @@ -12,10 +12,10 @@ fn f() i32 { } test "don't emit an LLVM global for a const function when it's in an optional in a struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try std.testing.expect(s.f.?() == 1234); } diff --git a/test/behavior/bugs/12776.zig b/test/behavior/bugs/12776.zig index 2061d6e80418..ad7293bae6da 100644 --- a/test/behavior/bugs/12776.zig +++ b/test/behavior/bugs/12776.zig @@ -29,11 +29,11 @@ const CPU = packed struct { }; test { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64) { + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) { // Careful enabling this test, fails randomly. return error.SkipZigTest; } diff --git a/test/behavior/bugs/12801-1.zig b/test/behavior/bugs/12801-1.zig index ff94382d1fcb..d97ee579662b 100644 --- a/test/behavior/bugs/12801-1.zig +++ b/test/behavior/bugs/12801-1.zig @@ -7,7 +7,7 @@ fn capacity_() u64 { } test { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO try std.testing.expect((@This(){}).capacity() == 64); } diff --git a/test/behavior/bugs/12801-2.zig b/test/behavior/bugs/12801-2.zig index 6b145e992577..4782f04cfd9c 100644 --- a/test/behavior/bugs/12801-2.zig +++ b/test/behavior/bugs/12801-2.zig @@ -14,10 +14,10 @@ const Auto = struct { } }; test { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a: Auto = .{ .offset = 16, .capacity = Auto.capacity }; try std.testing.expect(a.capacity() == 32); diff --git a/test/behavior/bugs/12890.zig b/test/behavior/bugs/12890.zig index a832f14cefbd..4537bfd7f0c8 100644 --- a/test/behavior/bugs/12890.zig +++ b/test/behavior/bugs/12890.zig @@ -9,9 +9,9 @@ fn a(b: []u3, c: u3) void { } } test { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var arr: [8]u3 = undefined; a(&arr, 5); diff --git a/test/behavior/bugs/12891.zig b/test/behavior/bugs/12891.zig index 9987a494e08f..61157ccccba3 100644 --- a/test/behavior/bugs/12891.zig +++ b/test/behavior/bugs/12891.zig @@ -7,53 +7,53 @@ test "issue12891" { try std.testing.expect(i < f); } test "nan" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const f = comptime std.math.nan(f64); var i: usize = 0; try std.testing.expect(!(f < i)); } test "inf" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const f = comptime std.math.inf(f64); var i: usize = 0; try std.testing.expect(f > i); } test "-inf < 0" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const f = comptime -std.math.inf(f64); var i: usize = 0; try std.testing.expect(f < i); } test "inf >= 1" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const f = comptime std.math.inf(f64); var i: usize = 1; try std.testing.expect(f >= i); } test "isNan(nan * 1)" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const nan_times_one = comptime std.math.nan(f64) * 1; try std.testing.expect(std.math.isNan(nan_times_one)); } test "runtime isNan(nan * 1)" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const nan_times_one = std.math.nan(f64) * 1; try std.testing.expect(std.math.isNan(nan_times_one)); } test "isNan(nan * 0)" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const nan_times_zero = comptime std.math.nan(f64) * 0; try std.testing.expect(std.math.isNan(nan_times_zero)); @@ -61,9 +61,9 @@ test "isNan(nan * 0)" { try std.testing.expect(std.math.isNan(zero_times_nan)); } test "isNan(inf * 0)" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const inf_times_zero = comptime std.math.inf(f64) * 0; try std.testing.expect(std.math.isNan(inf_times_zero)); @@ -71,9 +71,9 @@ test "isNan(inf * 0)" { try std.testing.expect(std.math.isNan(zero_times_inf)); } test "runtime isNan(nan * 0)" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const nan_times_zero = std.math.nan(f64) * 0; try std.testing.expect(std.math.isNan(nan_times_zero)); @@ -81,9 +81,9 @@ test "runtime isNan(nan * 0)" { try std.testing.expect(std.math.isNan(zero_times_nan)); } test "runtime isNan(inf * 0)" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const inf_times_zero = std.math.inf(f64) * 0; try std.testing.expect(std.math.isNan(inf_times_zero)); diff --git a/test/behavior/bugs/12928.zig b/test/behavior/bugs/12928.zig index dd5a7761d7a7..a2e4b66b9e30 100644 --- a/test/behavior/bugs/12928.zig +++ b/test/behavior/bugs/12928.zig @@ -11,7 +11,7 @@ const B = extern struct { }; test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: *A = undefined; try expect(@TypeOf(&a.value.a) == *volatile u32); @@ -26,7 +26,7 @@ const D = extern union { b: i32, }; test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var c: *C = undefined; try expect(@TypeOf(&c.value.a) == *volatile u32); diff --git a/test/behavior/bugs/12972.zig b/test/behavior/bugs/12972.zig index 329e993ab8da..78a3c1290e23 100644 --- a/test/behavior/bugs/12972.zig +++ b/test/behavior/bugs/12972.zig @@ -3,10 +3,10 @@ const builtin = @import("builtin"); pub fn f(_: [:null]const ?u8) void {} test { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const c: u8 = 42; f(&[_:null]?u8{c}); diff --git a/test/behavior/bugs/12984.zig b/test/behavior/bugs/12984.zig index 0b144ed159b8..9b0c269ec9a9 100644 --- a/test/behavior/bugs/12984.zig +++ b/test/behavior/bugs/12984.zig @@ -12,9 +12,9 @@ pub const OnConfirm = DeleagateWithContext(fn (bool) void); pub const CustomDraw = DeleagateWithContext(fn (?OnConfirm) void); test "simple test" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var c: CustomDraw = undefined; _ = c; diff --git a/test/behavior/bugs/13063.zig b/test/behavior/bugs/13063.zig index 30b086e72138..5a87eb3c1f68 100644 --- a/test/behavior/bugs/13063.zig +++ b/test/behavior/bugs/13063.zig @@ -4,7 +4,7 @@ const expect = std.testing.expect; var pos = [2]f32{ 0.0, 0.0 }; test "store to global array" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(pos[1] == 0.0); pos = [2]f32{ 0.0, 1.0 }; @@ -13,7 +13,7 @@ test "store to global array" { var vpos = @Vector(2, f32){ 0.0, 0.0 }; test "store to global vector" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(vpos[1] == 0.0); vpos = @Vector(2, f32){ 0.0, 1.0 }; diff --git a/test/behavior/bugs/13064.zig b/test/behavior/bugs/13064.zig index f997bb46b9c4..7907843f0d09 100644 --- a/test/behavior/bugs/13064.zig +++ b/test/behavior/bugs/13064.zig @@ -3,10 +3,10 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: [10][10]u32 = undefined; diff --git a/test/behavior/bugs/13065.zig b/test/behavior/bugs/13065.zig index d6c63db84bc2..1058f0a83fe6 100644 --- a/test/behavior/bugs/13065.zig +++ b/test/behavior/bugs/13065.zig @@ -8,10 +8,10 @@ const U = union(enum) { }; test { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x = U{ .array = undefined }; diff --git a/test/behavior/bugs/13068.zig b/test/behavior/bugs/13068.zig index 046a27cc153e..9750da7cdfff 100644 --- a/test/behavior/bugs/13068.zig +++ b/test/behavior/bugs/13068.zig @@ -5,11 +5,11 @@ pub const allocator = std.heap.page_allocator; var list = std.ArrayList(u32).init(allocator); test { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; list.items.len = 0; } diff --git a/test/behavior/bugs/13069.zig b/test/behavior/bugs/13069.zig index 916f3ba8002e..a49f15b22dd3 100644 --- a/test/behavior/bugs/13069.zig +++ b/test/behavior/bugs/13069.zig @@ -3,10 +3,10 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var opt_x: ?[3]f32 = [_]f32{0.0} ** 3; diff --git a/test/behavior/bugs/13113.zig b/test/behavior/bugs/13113.zig index fd3a14f8f613..d84f55599f32 100644 --- a/test/behavior/bugs/13113.zig +++ b/test/behavior/bugs/13113.zig @@ -7,10 +7,10 @@ const Foo = extern struct { }; test { - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const foo = Foo{ .a = 1, diff --git a/test/behavior/bugs/13128.zig b/test/behavior/bugs/13128.zig index b87513d51003..bc8f69a66330 100644 --- a/test/behavior/bugs/13128.zig +++ b/test/behavior/bugs/13128.zig @@ -12,10 +12,10 @@ fn foo(val: U) !void { } test "runtime union init, most-aligned field != largest" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u8 = 1; try foo(.{ .x = x }); diff --git a/test/behavior/bugs/13159.zig b/test/behavior/bugs/13159.zig index 6f8ae1842fb0..ba5d8fa145ba 100644 --- a/test/behavior/bugs/13159.zig +++ b/test/behavior/bugs/13159.zig @@ -10,8 +10,8 @@ const Bar = packed struct { }; test { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo = Bar.Baz.fizz; try expect(foo == .fizz); diff --git a/test/behavior/bugs/13285.zig b/test/behavior/bugs/13285.zig index b87020bf46fc..29f58e5f4c9c 100644 --- a/test/behavior/bugs/13285.zig +++ b/test/behavior/bugs/13285.zig @@ -5,8 +5,8 @@ const Crasher = struct { }; test { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: Crasher = undefined; var crasher_ptr = &a; diff --git a/test/behavior/bugs/13366.zig b/test/behavior/bugs/13366.zig index 8419fbe2654b..a76555b6a449 100644 --- a/test/behavior/bugs/13366.zig +++ b/test/behavior/bugs/13366.zig @@ -13,11 +13,11 @@ const Block = struct { }; test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: u32 = 16; var reason = .{ .c_import = .{ .a = a } }; diff --git a/test/behavior/bugs/13664.zig b/test/behavior/bugs/13664.zig index 828408510ddc..10bdf95a21fa 100644 --- a/test/behavior/bugs/13664.zig +++ b/test/behavior/bugs/13664.zig @@ -13,10 +13,10 @@ fn value() i64 { return 1341; } test { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const timestamp: i64 = value(); const id = ID{ .fields = Fields{ diff --git a/test/behavior/bugs/13785.zig b/test/behavior/bugs/13785.zig index 53d03f541361..d902d2294d9f 100644 --- a/test/behavior/bugs/13785.zig +++ b/test/behavior/bugs/13785.zig @@ -3,10 +3,10 @@ const std = @import("std"); const S = packed struct { a: u0 = 0 }; test { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: u8 = 0; try std.io.null_writer.print("\n{} {}\n", .{ a, S{} }); diff --git a/test/behavior/bugs/1381.zig b/test/behavior/bugs/1381.zig index cd0b289e5f73..f0c9db1e6c93 100644 --- a/test/behavior/bugs/1381.zig +++ b/test/behavior/bugs/1381.zig @@ -12,10 +12,10 @@ const A = union(enum) { }; test "union that needs padding bytes inside an array" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var as = [_]A{ A{ .B = B{ .D = 1 } }, diff --git a/test/behavior/bugs/1442.zig b/test/behavior/bugs/1442.zig index 7ce138dfd73f..d6304eecf4d5 100644 --- a/test/behavior/bugs/1442.zig +++ b/test/behavior/bugs/1442.zig @@ -7,10 +7,10 @@ const Union = union(enum) { }; test "const error union field alignment" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var union_or_err: anyerror!Union = Union{ .Color = 1234 }; try std.testing.expect((union_or_err catch unreachable).Color == 1234); diff --git a/test/behavior/bugs/14854.zig b/test/behavior/bugs/14854.zig index 9c877bc68873..d73f8d2eeb1a 100644 --- a/test/behavior/bugs/14854.zig +++ b/test/behavior/bugs/14854.zig @@ -2,7 +2,7 @@ const testing = @import("std").testing; const builtin = @import("builtin"); test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testing.expect(getGeneric(u8, getU8) == 123); } diff --git a/test/behavior/bugs/1486.zig b/test/behavior/bugs/1486.zig index ceeaf8811eb3..9bbcee9ebac3 100644 --- a/test/behavior/bugs/1486.zig +++ b/test/behavior/bugs/1486.zig @@ -6,8 +6,8 @@ const ptr = &global; var global: usize = 123; test "constant pointer to global variable causes runtime load" { - if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO global = 1234; try expect(&global == ptr); try expect(ptr.* == 1234); diff --git a/test/behavior/bugs/1500.zig b/test/behavior/bugs/1500.zig index 3a6246b2c991..998809d7e90d 100644 --- a/test/behavior/bugs/1500.zig +++ b/test/behavior/bugs/1500.zig @@ -6,7 +6,7 @@ const A = struct { const B = *const fn (A) void; test "allow these dependencies" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: A = undefined; var b: B = undefined; diff --git a/test/behavior/bugs/15778.zig b/test/behavior/bugs/15778.zig index 86b9fce7b62d..a851f290b0f2 100644 --- a/test/behavior/bugs/15778.zig +++ b/test/behavior/bugs/15778.zig @@ -1,24 +1,24 @@ const builtin = @import("builtin"); test { - if (builtin.zig_backend == .stage2_x86) 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_riscv64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_riscv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const a = @Vector(0, i32){}; const b = @Vector(0, i32){}; _ = a + b; } test { - if (builtin.zig_backend == .stage2_x86) 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_riscv64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_riscv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const a = @Vector(0, f32){}; const b = @Vector(0, f32){}; _ = a - b; diff --git a/test/behavior/bugs/1607.zig b/test/behavior/bugs/1607.zig index 32d5b38ba3ee..e867215ec6c3 100644 --- a/test/behavior/bugs/1607.zig +++ b/test/behavior/bugs/1607.zig @@ -11,10 +11,10 @@ fn checkAddress(s: []const u8) !void { } test "slices pointing at the same address as global array." { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try checkAddress(&a); try comptime checkAddress(&a); diff --git a/test/behavior/bugs/1735.zig b/test/behavior/bugs/1735.zig index 78fd59e41e20..218c8b511e96 100644 --- a/test/behavior/bugs/1735.zig +++ b/test/behavior/bugs/1735.zig @@ -42,9 +42,9 @@ const a = struct { }; test "initialization" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var t = a.init(); try std.testing.expect(t.foo.len == 0); diff --git a/test/behavior/bugs/1741.zig b/test/behavior/bugs/1741.zig index b4cf5577de35..8d4a2b376bcc 100644 --- a/test/behavior/bugs/1741.zig +++ b/test/behavior/bugs/1741.zig @@ -2,10 +2,10 @@ const std = @import("std"); const builtin = @import("builtin"); test "fixed" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const x: f32 align(128) = 12.34; try std.testing.expect(@intFromPtr(&x) % 128 == 0); diff --git a/test/behavior/bugs/1851.zig b/test/behavior/bugs/1851.zig index 4af02feaca90..1838b3a087d0 100644 --- a/test/behavior/bugs/1851.zig +++ b/test/behavior/bugs/1851.zig @@ -3,17 +3,17 @@ const std = @import("std"); const expect = std.testing.expect; test "allocation and looping over 3-byte integer" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .macos) { + if (builtin.zig_backend == .zsf_llvm and builtin.os.tag == .macos) { return error.SkipZigTest; // TODO } - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .wasm32) { + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .wasm32) { return error.SkipZigTest; // TODO } diff --git a/test/behavior/bugs/1914.zig b/test/behavior/bugs/1914.zig index 14f4b0be27eb..5300bd5eb235 100644 --- a/test/behavior/bugs/1914.zig +++ b/test/behavior/bugs/1914.zig @@ -12,7 +12,7 @@ const b_list: []B = &[_]B{}; const a = A{ .b_list_pointer = &b_list }; test "segfault bug" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const assert = std.debug.assert; const obj = B{ .a_pointer = &a }; @@ -30,7 +30,7 @@ pub const B2 = struct { var b_value = B2{ .pointer_array = &[_]*A2{} }; test "basic stuff" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; std.debug.assert(&b_value == &b_value); } diff --git a/test/behavior/bugs/2006.zig b/test/behavior/bugs/2006.zig index 40f03d5b0bf8..0b42dfdb7da7 100644 --- a/test/behavior/bugs/2006.zig +++ b/test/behavior/bugs/2006.zig @@ -6,8 +6,8 @@ const S = struct { p: *S, }; test "bug 2006" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: S = undefined; a = S{ .p = undefined }; diff --git a/test/behavior/bugs/2114.zig b/test/behavior/bugs/2114.zig index c785928024aa..b1ea0d944dc7 100644 --- a/test/behavior/bugs/2114.zig +++ b/test/behavior/bugs/2114.zig @@ -8,13 +8,13 @@ fn ctz(x: anytype) usize { } test "fixed" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64 and !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .bmi)) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testCtz(); try comptime testCtz(); diff --git a/test/behavior/bugs/2578.zig b/test/behavior/bugs/2578.zig index 9cf34e980d77..f5062ed5c9f5 100644 --- a/test/behavior/bugs/2578.zig +++ b/test/behavior/bugs/2578.zig @@ -12,10 +12,10 @@ fn bar(pointer: ?*anyopaque) void { } test "fixed" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; bar(t); } diff --git a/test/behavior/bugs/2622.zig b/test/behavior/bugs/2622.zig index d3d2b078e2a6..0a7ed8982442 100644 --- a/test/behavior/bugs/2622.zig +++ b/test/behavior/bugs/2622.zig @@ -3,11 +3,11 @@ const builtin = @import("builtin"); var buf: []u8 = undefined; test "reslice of undefined global var slice" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var mem: [100]u8 = [_]u8{0} ** 100; buf = &mem; diff --git a/test/behavior/bugs/2692.zig b/test/behavior/bugs/2692.zig index 0eed28b2e7b4..8486d0b2696a 100644 --- a/test/behavior/bugs/2692.zig +++ b/test/behavior/bugs/2692.zig @@ -5,9 +5,9 @@ fn foo(a: []u8) void { } test "address of 0 length array" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var pt: [0]u8 = undefined; foo(&pt); diff --git a/test/behavior/bugs/2727.zig b/test/behavior/bugs/2727.zig index 9e0def70d48d..84820e7867ef 100644 --- a/test/behavior/bugs/2727.zig +++ b/test/behavior/bugs/2727.zig @@ -5,10 +5,10 @@ fn t() bool { } test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO comptime var i: usize = 0; inline while (i < 2) : (i += 1) { diff --git a/test/behavior/bugs/2889.zig b/test/behavior/bugs/2889.zig index 69ec35355a45..74db7bfe65c1 100644 --- a/test/behavior/bugs/2889.zig +++ b/test/behavior/bugs/2889.zig @@ -27,9 +27,9 @@ fn parseNote() ?i32 { } test "fixed" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const result = parseNote(); try std.testing.expect(result.? == 9); diff --git a/test/behavior/bugs/3007.zig b/test/behavior/bugs/3007.zig index 7adec60a3b58..7df4006bbccf 100644 --- a/test/behavior/bugs/3007.zig +++ b/test/behavior/bugs/3007.zig @@ -19,10 +19,10 @@ fn get_foo() Foo.FooError!*Foo { } test "fixed" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; default_foo = get_foo() catch null; // This Line try std.testing.expect(!default_foo.?.free); diff --git a/test/behavior/bugs/3046.zig b/test/behavior/bugs/3046.zig index 683ece874ee3..22b4f0598a7a 100644 --- a/test/behavior/bugs/3046.zig +++ b/test/behavior/bugs/3046.zig @@ -13,10 +13,10 @@ fn couldFail() anyerror!i32 { var some_struct: SomeStruct = undefined; test "fixed" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; some_struct = SomeStruct{ .field = couldFail() catch @as(i32, 0), diff --git a/test/behavior/bugs/3112.zig b/test/behavior/bugs/3112.zig index b1dc2e290888..e5dc424392b3 100644 --- a/test/behavior/bugs/3112.zig +++ b/test/behavior/bugs/3112.zig @@ -12,10 +12,10 @@ fn prev(p: ?State) void { } test "zig test crash" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var global: State = undefined; global.enter = prev; diff --git a/test/behavior/bugs/3367.zig b/test/behavior/bugs/3367.zig index 775e918f63c6..0a2271291f62 100644 --- a/test/behavior/bugs/3367.zig +++ b/test/behavior/bugs/3367.zig @@ -10,7 +10,7 @@ const Mixin = struct { }; test "container member access usingnamespace decls" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo = Foo{}; foo.two(); diff --git a/test/behavior/bugs/3586.zig b/test/behavior/bugs/3586.zig index 19527147280a..e39b254d15c1 100644 --- a/test/behavior/bugs/3586.zig +++ b/test/behavior/bugs/3586.zig @@ -7,7 +7,7 @@ const Container = struct { }; test "fixed" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var ctr = Container{ .params = NoteParams{}, diff --git a/test/behavior/bugs/3742.zig b/test/behavior/bugs/3742.zig index 09d209912ea6..40e12b5d4e22 100644 --- a/test/behavior/bugs/3742.zig +++ b/test/behavior/bugs/3742.zig @@ -35,12 +35,12 @@ pub const ArgSerializer = struct { }; test "fixed" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_llvm and + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; ArgSerializer.serializeCommand(GET.init("banana")); } diff --git a/test/behavior/bugs/3779.zig b/test/behavior/bugs/3779.zig index 2b1dad5de0c0..584d342c7c0a 100644 --- a/test/behavior/bugs/3779.zig +++ b/test/behavior/bugs/3779.zig @@ -6,9 +6,9 @@ const tag_name = @tagName(TestEnum.TestEnumValue); const ptr_tag_name: [*:0]const u8 = tag_name; test "@tagName() returns a string literal" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name)); try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name)); @@ -20,9 +20,9 @@ const error_name = @errorName(TestError.TestErrorCode); const ptr_error_name: [*:0]const u8 = error_name; test "@errorName() returns a string literal" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name)); try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name)); @@ -34,9 +34,9 @@ const type_name = @typeName(TestType); const ptr_type_name: [*:0]const u8 = type_name; test "@typeName() returns a string literal" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name)); try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", type_name)); @@ -48,9 +48,9 @@ const ptr_actual_contents: [*:0]const u8 = actual_contents; const expected_contents = "hello zig\n"; test "@embedFile() returns a string literal" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents)); try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents)); @@ -63,9 +63,9 @@ fn testFnForSrc() std.builtin.SourceLocation { } test "@src() returns a struct containing 0-terminated string slices" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const src = testFnForSrc(); try std.testing.expect([:0]const u8 == @TypeOf(src.file)); diff --git a/test/behavior/bugs/421.zig b/test/behavior/bugs/421.zig index f92bfb989949..8cadfea3bd62 100644 --- a/test/behavior/bugs/421.zig +++ b/test/behavior/bugs/421.zig @@ -2,10 +2,10 @@ const builtin = @import("builtin"); const expect = @import("std").testing.expect; test "bitCast to array" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testBitCastArray(); try testBitCastArray(); diff --git a/test/behavior/bugs/4328.zig b/test/behavior/bugs/4328.zig index 846f751815b7..115804bfddc3 100644 --- a/test/behavior/bugs/4328.zig +++ b/test/behavior/bugs/4328.zig @@ -17,7 +17,7 @@ const S = extern struct { }; test "Extern function calls in @TypeOf" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Test = struct { fn test_fn_1(a: anytype, b: anytype) @TypeOf(c_printf("%d %s\n", a, b)) { @@ -39,7 +39,7 @@ test "Extern function calls in @TypeOf" { } test "Peer resolution of extern function calls in @TypeOf" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Test = struct { fn test_fn() @TypeOf(c_ftell(null), c_fputs(null, null)) { @@ -56,9 +56,9 @@ test "Peer resolution of extern function calls in @TypeOf" { } test "Extern function calls, dereferences and field access in @TypeOf" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Test = struct { fn test_fn_1(a: c_long) @TypeOf(c_fopen("test", "r").*) { diff --git a/test/behavior/bugs/4560.zig b/test/behavior/bugs/4560.zig index ca9a34ea8975..46654dda3b28 100644 --- a/test/behavior/bugs/4560.zig +++ b/test/behavior/bugs/4560.zig @@ -2,7 +2,7 @@ const std = @import("std"); const builtin = @import("builtin"); test "fixed" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var s: S = .{ .a = 1, diff --git a/test/behavior/bugs/4954.zig b/test/behavior/bugs/4954.zig index 15c3185fa9d4..4746efc59898 100644 --- a/test/behavior/bugs/4954.zig +++ b/test/behavior/bugs/4954.zig @@ -5,10 +5,10 @@ fn f(buf: []u8) void { } test "crash" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buf: [4096]u8 = undefined; f(&buf); diff --git a/test/behavior/bugs/529.zig b/test/behavior/bugs/529.zig index 49a9b0a46d50..a1182454979b 100644 --- a/test/behavior/bugs/529.zig +++ b/test/behavior/bugs/529.zig @@ -11,11 +11,11 @@ comptime { const builtin = @import("builtin"); test "issue 529 fixed" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; @import("529_other_file.zig").issue529(null); issue529(null); diff --git a/test/behavior/bugs/5398.zig b/test/behavior/bugs/5398.zig index 4dc4ab8d190f..6920c3c68937 100644 --- a/test/behavior/bugs/5398.zig +++ b/test/behavior/bugs/5398.zig @@ -19,10 +19,10 @@ pub const Renderable = struct { var renderable: Renderable = undefined; test "assignment of field with padding" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; renderable = Renderable{ .mesh = Mesh{ .id = 0 }, diff --git a/test/behavior/bugs/5474.zig b/test/behavior/bugs/5474.zig index ee58a93124dc..86bb154e6b7d 100644 --- a/test/behavior/bugs/5474.zig +++ b/test/behavior/bugs/5474.zig @@ -49,14 +49,14 @@ fn constant() !void { } test "pointer-to-array constness for zero-size elements, var" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try mutable(); try comptime mutable(); } test "pointer-to-array constness for zero-size elements, const" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try constant(); try comptime constant(); diff --git a/test/behavior/bugs/5487.zig b/test/behavior/bugs/5487.zig index 3ea8cad220a0..fd799a4691a8 100644 --- a/test/behavior/bugs/5487.zig +++ b/test/behavior/bugs/5487.zig @@ -10,8 +10,8 @@ pub fn writer() io.Writer(void, @typeInfo(@typeInfo(@TypeOf(write)).Fn.return_ty } test "crash" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO _ = io.multiWriter(.{writer()}); } diff --git a/test/behavior/bugs/6047.zig b/test/behavior/bugs/6047.zig index 54e1fd20d623..8a4144a5f765 100644 --- a/test/behavior/bugs/6047.zig +++ b/test/behavior/bugs/6047.zig @@ -10,11 +10,11 @@ fn getError2() !void { } test "`try`ing an if/else expression" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try @import("std").testing.expectError(error.Test, getError2()); } diff --git a/test/behavior/bugs/624.zig b/test/behavior/bugs/624.zig index a0a93c0104f9..ac678abf0466 100644 --- a/test/behavior/bugs/624.zig +++ b/test/behavior/bugs/624.zig @@ -20,9 +20,9 @@ fn MemoryPool(comptime T: type) type { } test "foo" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var allocator = ContextAllocator{ .n = 10 }; try expect(allocator.n == 10); diff --git a/test/behavior/bugs/6456.zig b/test/behavior/bugs/6456.zig index 31dea02cf67f..930907d04ef1 100644 --- a/test/behavior/bugs/6456.zig +++ b/test/behavior/bugs/6456.zig @@ -11,9 +11,9 @@ const text = ; test "issue 6456" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { var fields: []const StructField = &[0]StructField{}; diff --git a/test/behavior/bugs/656.zig b/test/behavior/bugs/656.zig index 161da66964d2..1ba0b1882cd7 100644 --- a/test/behavior/bugs/656.zig +++ b/test/behavior/bugs/656.zig @@ -11,10 +11,10 @@ const Value = struct { }; test "optional if after an if in a switch prong of a switch with 2 prongs in an else" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try foo(false, true); } diff --git a/test/behavior/bugs/6781.zig b/test/behavior/bugs/6781.zig index aac0c31a11fc..9c3ae1ad8ce5 100644 --- a/test/behavior/bugs/6781.zig +++ b/test/behavior/bugs/6781.zig @@ -62,13 +62,13 @@ pub const JournalHeader = packed struct { }; test "fixed" { - 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_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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buffer align(@alignOf(JournalHeader)) = [_]u8{0} ** 65536; var entry = std.mem.bytesAsValue(JournalHeader, buffer[0..@sizeOf(JournalHeader)]); diff --git a/test/behavior/bugs/6905.zig b/test/behavior/bugs/6905.zig index 5792713c89ec..38cc5f1f034f 100644 --- a/test/behavior/bugs/6905.zig +++ b/test/behavior/bugs/6905.zig @@ -2,11 +2,11 @@ const expect = @import("std").testing.expect; const builtin = @import("builtin"); test "sentinel-terminated 0-length slices" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 }; diff --git a/test/behavior/bugs/6947.zig b/test/behavior/bugs/6947.zig index 9aff7b992e7e..6e24b84d1c14 100644 --- a/test/behavior/bugs/6947.zig +++ b/test/behavior/bugs/6947.zig @@ -5,11 +5,11 @@ fn destroy(ptr: *void) void { } test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var slice: []void = undefined; destroy(&slice[0]); diff --git a/test/behavior/bugs/7047.zig b/test/behavior/bugs/7047.zig index a7a09669350c..4d8b8b463ce1 100644 --- a/test/behavior/bugs/7047.zig +++ b/test/behavior/bugs/7047.zig @@ -15,7 +15,7 @@ fn S(comptime query: U) type { } test "compiler doesn't consider equal unions with different 'type' payload" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const s1 = S(U{ .T = u32 }).tag(); try std.testing.expectEqual(u32, s1); diff --git a/test/behavior/bugs/718.zig b/test/behavior/bugs/718.zig index 0dad101e4b28..691902c2dcfd 100644 --- a/test/behavior/bugs/718.zig +++ b/test/behavior/bugs/718.zig @@ -10,10 +10,10 @@ const Keys = struct { }; var keys: Keys = undefined; test "zero keys with @memset" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; @memset(@as([*]u8, @ptrCast(&keys))[0..@sizeOf(@TypeOf(keys))], 0); try expect(!keys.up); diff --git a/test/behavior/bugs/7187.zig b/test/behavior/bugs/7187.zig index be593d7fad8c..8306a2e23ad9 100644 --- a/test/behavior/bugs/7187.zig +++ b/test/behavior/bugs/7187.zig @@ -3,7 +3,7 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test "miscompilation with bool return type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: usize = 1; var y: bool = getFalse(); diff --git a/test/behavior/bugs/726.zig b/test/behavior/bugs/726.zig index 37e8d31cc942..0698415fb4ca 100644 --- a/test/behavior/bugs/726.zig +++ b/test/behavior/bugs/726.zig @@ -2,10 +2,10 @@ const expect = @import("std").testing.expect; const builtin = @import("builtin"); test "@ptrCast from const to nullable" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const c: u8 = 4; var x: ?*const u8 = @as(?*const u8, @ptrCast(&c)); @@ -13,10 +13,10 @@ test "@ptrCast from const to nullable" { } test "@ptrCast from var in empty struct to nullable" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const container = struct { var c: u8 = 4; diff --git a/test/behavior/bugs/7325.zig b/test/behavior/bugs/7325.zig index 5c0c55a64460..5042047e9ad8 100644 --- a/test/behavior/bugs/7325.zig +++ b/test/behavior/bugs/7325.zig @@ -78,11 +78,11 @@ fn genExpression(expr: Expression) !ExpressionResult { } test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var param: ParamType = .{ .one_of = .{ .name = "name" }, diff --git a/test/behavior/bugs/8277.zig b/test/behavior/bugs/8277.zig index 149962d99664..b9c47c6fc456 100644 --- a/test/behavior/bugs/8277.zig +++ b/test/behavior/bugs/8277.zig @@ -2,7 +2,7 @@ const std = @import("std"); const builtin = @import("builtin"); test "@sizeOf reified union zero-size payload fields" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union {})))); diff --git a/test/behavior/bugs/828.zig b/test/behavior/bugs/828.zig index a0ac00817d73..a83695c768cb 100644 --- a/test/behavior/bugs/828.zig +++ b/test/behavior/bugs/828.zig @@ -30,8 +30,8 @@ fn constCount(comptime cb: *const CountBy, comptime unused: u32) void { } test "comptime struct return should not return the same instance" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; //the first parameter must be passed by reference to trigger the bug //a second parameter is required to trigger the bug diff --git a/test/behavior/bugs/8646.zig b/test/behavior/bugs/8646.zig index 1bd81f799f44..82d66161bfbf 100644 --- a/test/behavior/bugs/8646.zig +++ b/test/behavior/bugs/8646.zig @@ -7,11 +7,11 @@ const array = [_][]const []const u8{ }; test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try std.testing.expect(array[0].len == 1); try std.testing.expectEqualStrings("hello", array[0][0]); diff --git a/test/behavior/bugs/920.zig b/test/behavior/bugs/920.zig index 8a9bf51512b6..c67f5f07bd76 100644 --- a/test/behavior/bugs/920.zig +++ b/test/behavior/bugs/920.zig @@ -57,12 +57,12 @@ const NormalDist = blk: { }; test "bug 920 fixed" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const NormalDist1 = blk: { break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case); diff --git a/test/behavior/bugs/9584.zig b/test/behavior/bugs/9584.zig index 6f3223c36225..e493009f1320 100644 --- a/test/behavior/bugs/9584.zig +++ b/test/behavior/bugs/9584.zig @@ -44,10 +44,10 @@ pub fn b(x: *X) !void { } test { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var flags = A{ .a = false, diff --git a/test/behavior/builtin_functions_returning_void_or_noreturn.zig b/test/behavior/builtin_functions_returning_void_or_noreturn.zig index 1eb2ef3049ff..52c45650420c 100644 --- a/test/behavior/builtin_functions_returning_void_or_noreturn.zig +++ b/test/behavior/builtin_functions_returning_void_or_noreturn.zig @@ -6,11 +6,11 @@ var x: u8 = 1; // This excludes builtin functions that return void or noreturn that cannot be tested. test { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_riscv64) return error.SkipZigTest; // TODO var val: u8 = undefined; try testing.expectEqual({}, @atomicStore(u8, &val, 0, .Unordered)); diff --git a/test/behavior/byteswap.zig b/test/behavior/byteswap.zig index ce33834ffa7d..03a8e954847d 100644 --- a/test/behavior/byteswap.zig +++ b/test/behavior/byteswap.zig @@ -3,12 +3,12 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test "@byteSwap integers" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - 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; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const ByteSwapIntTest = struct { fn run() !void { @@ -62,12 +62,12 @@ fn vector8() !void { } test "@byteSwap vectors u8" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - 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; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime vector8(); try vector8(); @@ -81,12 +81,12 @@ fn vector16() !void { } test "@byteSwap vectors u16" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - 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; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime vector16(); try vector16(); @@ -100,12 +100,12 @@ fn vector24() !void { } test "@byteSwap vectors u24" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - 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; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime vector24(); try vector24(); @@ -119,7 +119,7 @@ fn vector0() !void { } test "@byteSwap vectors u0" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; try comptime vector0(); try vector0(); diff --git a/test/behavior/byval_arg_var.zig b/test/behavior/byval_arg_var.zig index 3a82ca86ad2e..8c6d2596b903 100644 --- a/test/behavior/byval_arg_var.zig +++ b/test/behavior/byval_arg_var.zig @@ -4,8 +4,8 @@ const builtin = @import("builtin"); var result: []const u8 = "wrong"; test "pass string literal byvalue to a generic var param" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; start(); blowUpStack(10); diff --git a/test/behavior/c_char_signedness.zig b/test/behavior/c_char_signedness.zig index 6b0bfe4049b2..1df0bc006d8f 100644 --- a/test/behavior/c_char_signedness.zig +++ b/test/behavior/c_char_signedness.zig @@ -6,7 +6,7 @@ const c = @cImport({ }); test "c_char signedness" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqual(@as(c_char, c.CHAR_MIN), std.math.minInt(c_char)); try expectEqual(@as(c_char, c.CHAR_MAX), std.math.maxInt(c_char)); diff --git a/test/behavior/call.zig b/test/behavior/call.zig index d641d5d5ba76..f3a45c22b4a7 100644 --- a/test/behavior/call.zig +++ b/test/behavior/call.zig @@ -19,12 +19,12 @@ test "super basic invocations" { } test "basic invocations" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const foo = struct { fn foo() i32 { @@ -54,10 +54,10 @@ test "basic invocations" { } test "tuple parameters" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const add = struct { fn add(a: i32, b: i32) i32 { @@ -87,10 +87,10 @@ test "tuple parameters" { } test "result location of function call argument through runtime condition and struct init" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const E = enum { a, b }; const S = struct { @@ -108,7 +108,7 @@ test "result location of function call argument through runtime condition and st } test "function call with 40 arguments" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest(thirty_nine: i32) !void { @@ -262,15 +262,15 @@ test "arguments to comptime parameters generated in comptime blocks" { } test "forced tail call" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - - if (builtin.zig_backend == .stage2_llvm) { + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + + if (builtin.zig_backend == .zsf_llvm) { // Only attempt this test on targets we know have tail call support in LLVM. if (builtin.cpu.arch != .x86_64 and builtin.cpu.arch != .aarch64) { return error.SkipZigTest; @@ -296,15 +296,15 @@ test "forced tail call" { } test "inline call preserves tail call" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - - if (builtin.zig_backend == .stage2_llvm) { + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + + if (builtin.zig_backend == .zsf_llvm) { // Only attempt this test on targets we know have tail call support in LLVM. if (builtin.cpu.arch != .x86_64 and builtin.cpu.arch != .aarch64) { return error.SkipZigTest; @@ -332,9 +332,9 @@ test "inline call preserves tail call" { } test "inline call doesn't re-evaluate non generic struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo(f: struct { a: u8, b: u8 }) !void { @@ -399,9 +399,9 @@ test "recursive inline call with comptime known argument" { } test "inline while with @call" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn inc(a: *u32) void { @@ -417,7 +417,7 @@ test "inline while with @call" { } test "method call as parameter type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo(x: anytype, y: @TypeOf(x).Inner()) @TypeOf(y) { @@ -432,12 +432,12 @@ test "method call as parameter type" { } test "non-anytype generic parameters provide result type" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { fn f(comptime T: type, y: T) !void { @@ -463,12 +463,12 @@ test "non-anytype generic parameters provide result type" { } test "argument to generic function has correct result type" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { fn foo(_: anytype, e: enum { a, b }) bool { diff --git a/test/behavior/call_tail.zig b/test/behavior/call_tail.zig index 10ef766a655f..4d8420817542 100644 --- a/test/behavior/call_tail.zig +++ b/test/behavior/call_tail.zig @@ -44,8 +44,8 @@ test "arguments pointed to on stack into tailcall" { => return error.SkipZigTest, else => {}, } - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; var data = [_]u64{ 1, 6, 2, 7, 1, 9, 3 }; base = @intFromPtr(&data); diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig index 742f6b5af508..1410e40a7674 100644 --- a/test/behavior/cast.zig +++ b/test/behavior/cast.zig @@ -21,9 +21,9 @@ test "integer literal to pointer cast" { } test "peer type resolution: ?T and T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(peerTypeTAndOptionalT(true, false).? == 0); try expect(peerTypeTAndOptionalT(false, false).? == 3); @@ -97,9 +97,9 @@ test "comptime_int @floatFromInt" { } test "@floatFromInt" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -117,13 +117,13 @@ test "@floatFromInt" { } test "@floatFromInt(f80)" { - if (builtin.zig_backend == .stage2_aarch64) 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_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; const S = struct { fn doTheTest(comptime Int: type) !void { @@ -154,10 +154,10 @@ test "@floatFromInt(f80)" { } test "@intFromFloat" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testIntFromFloats(); try comptime testIntFromFloats(); @@ -178,9 +178,9 @@ fn expectIntFromFloat(comptime F: type, f: F, comptime I: type, i: I) !void { } test "implicitly cast indirect pointer to maybe-indirect pointer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Self = @This(); @@ -238,10 +238,10 @@ test "@floatCast comptime_int and comptime_float" { } test "coerce undefined to optional" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(MakeType(void).getNull() == null); try expect(MakeType(void).getNonNull() != null); @@ -260,9 +260,9 @@ fn MakeType(comptime T: type) type { } test "implicit cast from *[N]T to [*c]T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: [4]u16 = [4]u16{ 0, 1, 2, 3 }; var y: [*c]u16 = &x; @@ -274,7 +274,7 @@ test "implicit cast from *[N]T to [*c]T" { } test "*usize to *void" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var i = @as(usize, 0); var v = @as(*void, @ptrCast(&i)); @@ -299,9 +299,9 @@ test "@intCast to u0 and use the result" { } test "peer result null and comptime_int" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn blah(n: i32) ?i32 { @@ -324,8 +324,8 @@ test "peer result null and comptime_int" { } test "*const ?[*]const T to [*c]const [*c]const T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var array = [_]u8{ 'o', 'k' }; const opt_array_ptr: ?[*]const u8 = &array; @@ -336,9 +336,9 @@ 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; @setRuntimeSafety(true); @@ -366,9 +366,9 @@ fn implicitIntLitToOptional() void { } test "return u8 coercing into ?u32 return type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -388,9 +388,9 @@ test "cast from ?[*]T to ??[*]T" { } test "peer type unsigned int to signed" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var w: u31 = 5; var x: u8 = 7; @@ -401,9 +401,9 @@ 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: [*:0]const u8 = "hello"; var b: [*c]const u8 = a; @@ -412,10 +412,10 @@ test "expected [*c]const u8, found [*:0]const u8" { } test "explicit cast from integer to error type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testCastIntToErr(error.ItBroke); try comptime testCastIntToErr(error.ItBroke); @@ -427,9 +427,9 @@ fn testCastIntToErr(err: anyerror) !void { } test "peer resolve array and const slice" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testPeerResolveArrayConstSlice(true); try comptime testPeerResolveArrayConstSlice(true); @@ -442,10 +442,10 @@ fn testPeerResolveArrayConstSlice(b: bool) !void { } test "implicitly cast from T to anyerror!?T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try castToOptionalTypeError(1); try comptime castToOptionalTypeError(1); @@ -469,9 +469,9 @@ fn castToOptionalTypeError(z: i32) !void { } test "implicitly cast from [0]T to anyerror![]T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testCastZeroArrayToErrSliceMut(); try comptime testCastZeroArrayToErrSliceMut(); @@ -486,10 +486,10 @@ fn gimmeErrOrSlice() anyerror![]u8 { } test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() anyerror!void { @@ -519,9 +519,9 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 { } test "implicit cast from *const [N]T to []const T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testCastConstArrayRefToConstSlice(); try comptime testCastConstArrayRefToConstSlice(); @@ -545,9 +545,9 @@ fn testCastConstArrayRefToConstSlice() !void { } test "peer type resolution: error and [N]T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); try comptime expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); @@ -570,9 +570,9 @@ fn testPeerErrorAndArray2(x: u8) anyerror![]const u8 { } test "single-item pointer of array to slice to unknown length pointer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testCastPtrOfArrayToSliceAndPtr(); try comptime testCastPtrOfArrayToSliceAndPtr(); @@ -600,9 +600,9 @@ fn testCastPtrOfArrayToSliceAndPtr() !void { } test "cast *[1][*]const u8 to [*]const ?[*]const u8" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const window_name = [1][*]const u8{"window name"}; const x: [*]const ?[*]const u8 = &window_name; @@ -610,12 +610,12 @@ test "cast *[1][*]const u8 to [*]const ?[*]const u8" { } test "vector casts" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -654,10 +654,10 @@ test "vector casts" { } test "@floatCast cast down" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var double: f64 = 0.001534; @@ -672,9 +672,9 @@ test "@floatCast cast down" { } test "peer type resolution: unreachable, error set, unreachable" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Error = error{ FileDescriptorAlreadyPresentInSet, @@ -706,10 +706,10 @@ test "peer cast: error set any anyerror" { } test "peer type resolution: error set supersets" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a: error{ One, Two } = undefined; const b: error{One} = undefined; @@ -736,10 +736,10 @@ test "peer type resolution: error set supersets" { } test "peer type resolution: disjoint error sets" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a: error{ One, Two } = undefined; const b: error{Three} = undefined; @@ -766,10 +766,10 @@ test "peer type resolution: disjoint error sets" { } test "peer type resolution: error union and error set" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a: error{Three} = undefined; const b: error{ One, Two }!u32 = undefined; @@ -800,10 +800,10 @@ test "peer type resolution: error union and error set" { } test "peer type resolution: error union after non-error" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a: u32 = undefined; const b: error{ One, Two }!u32 = undefined; @@ -834,10 +834,10 @@ test "peer type resolution: error union after non-error" { } test "peer cast *[0]T to E![]const T" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buffer: [5]u8 = "abcde".*; var buf: anyerror![]const u8 = buffer[0..]; @@ -849,10 +849,10 @@ test "peer cast *[0]T to E![]const T" { } test "peer cast *[0]T to []const T" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buffer: [5]u8 = "abcde".*; var buf: []const u8 = buffer[0..]; @@ -862,8 +862,8 @@ test "peer cast *[0]T to []const T" { } test "peer cast *[N]T to [*]T" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var array = [4:99]i32{ 1, 2, 3, 4 }; var dest: [*]i32 = undefined; @@ -872,10 +872,10 @@ test "peer cast *[N]T to [*]T" { } test "peer resolution of string literals" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const E = enum { a, b, c, d }; @@ -895,9 +895,9 @@ test "peer resolution of string literals" { } test "peer cast [:x]T to []T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -912,9 +912,9 @@ test "peer cast [:x]T to []T" { } test "peer cast [N:x]T to [N]T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -928,9 +928,9 @@ test "peer cast [N:x]T to [N]T" { } test "peer cast *[N:x]T to *[N]T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -944,9 +944,9 @@ test "peer cast *[N:x]T to *[N]T" { } test "peer cast [*:x]T to [*]T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -964,10 +964,10 @@ test "peer cast [*:x]T to [*]T" { } test "peer cast [:x]T to [*:x]T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -986,9 +986,9 @@ test "peer cast [:x]T to [*:x]T" { } test "peer type resolution implicit cast to return type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1007,9 +1007,9 @@ test "peer type resolution implicit cast to return type" { } test "peer type resolution implicit cast to variable type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1032,9 +1032,9 @@ test "variable initialization uses result locations properly with regards to the } test "cast between C pointer with different but compatible types" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo(arg: [*]c_ushort) u16 { @@ -1050,9 +1050,9 @@ test "cast between C pointer with different but compatible types" { } test "peer type resolve string lit with sentinel-terminated mutable slice" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var array: [4:0]u8 = undefined; array[4] = 0; // TODO remove this when #4372 is solved @@ -1062,7 +1062,7 @@ test "peer type resolve string lit with sentinel-terminated mutable slice" { } test "peer type resolve array pointers, one of them const" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var array1: [4]u8 = undefined; const array2: [5]u8 = undefined; @@ -1071,7 +1071,7 @@ test "peer type resolve array pointers, one of them const" { } test "peer type resolve array pointer and unknown pointer" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const const_array: [4]u8 = undefined; var array: [4]u8 = undefined; @@ -1092,7 +1092,7 @@ test "peer type resolve array pointer and unknown pointer" { } test "comptime float casts" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a = @as(comptime_float, @floatFromInt(1)); try expect(a == 1); @@ -1106,8 +1106,8 @@ test "comptime float casts" { } test "pointer reinterpret const float to int" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO // The hex representation is 0x3fe3333333333303. const float: f64 = 5.99999999999994648725e-01; @@ -1121,10 +1121,10 @@ test "pointer reinterpret const float to int" { } test "implicit cast from [*]T to ?*anyopaque" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a = [_]u8{ 3, 2, 1 }; var runtime_zero: usize = 0; @@ -1140,7 +1140,7 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void { } test "compile time int to ptr of function" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try foobar(FUNCTION_CONSTANT); } @@ -1178,10 +1178,10 @@ test "cast function with an opaque parameter" { } test "implicit ptr to *anyopaque" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: u32 = 1; var ptr: *align(@alignOf(u32)) anyopaque = &a; @@ -1193,9 +1193,9 @@ test "implicit ptr to *anyopaque" { } test "return null from fn() anyerror!?&T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a = returnNullFromOptionalTypeErrorRef(); const b = returnNullLitFromOptionalTypeErrorRef(); @@ -1210,9 +1210,9 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A { } test "peer type resolution: [0]u8 and []const u8" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0); try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1); @@ -1230,10 +1230,10 @@ fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 { } test "implicitly cast from [N]T to ?[]const T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, castToOptionalSlice().?, "hi")); try comptime expect(mem.eql(u8, castToOptionalSlice().?, "hi")); @@ -1244,11 +1244,11 @@ fn castToOptionalSlice() ?[]const u8 { } test "cast u128 to f128 and back" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testCast128(); try testCast128(); @@ -1267,10 +1267,10 @@ fn cast128Float(x: u128) f128 { } test "implicit cast from *[N]T to ?[*]T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: ?[*]u16 = null; var y: [4]u16 = [4]u16{ 0, 1, 2, 3 }; @@ -1283,10 +1283,10 @@ test "implicit cast from *[N]T to ?[*]T" { } test "implicit cast from *T to ?*anyopaque" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: u8 = 1; incrementVoidPtrValue(&a); @@ -1298,9 +1298,9 @@ fn incrementVoidPtrValue(value: ?*anyopaque) void { } test "implicit cast *[0]T to E![]const u8" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x = @as(anyerror![]const u8, &[0]u8{}); try expect((x catch unreachable).len == 0); @@ -1317,10 +1317,10 @@ test "cast from array reference to fn: runtime fn ptr" { } test "*const [N]null u8 to ?[]const u8" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1334,7 +1334,7 @@ test "*const [N]null u8 to ?[]const u8" { } test "cast between [*c]T and ?[*:0]T on fn parameter" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Handler = ?fn ([*c]const u8) callconv(.C) void; @@ -1355,17 +1355,17 @@ test "cast between [*c]T and ?[*:0]T on fn parameter" { var global_struct: struct { f0: usize } = undefined; test "assignment to optional pointer result loc" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo: struct { ptr: ?*anyopaque } = .{ .ptr = &global_struct }; try expect(foo.ptr.? == @as(*anyopaque, @ptrCast(&global_struct))); } test "cast between *[N]void and []void" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: [4]void = undefined; var b: []void = &a; @@ -1373,9 +1373,9 @@ test "cast between *[N]void and []void" { } test "peer resolve arrays of different size to const slice" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, boolToStr(true), "true")); try expect(mem.eql(u8, boolToStr(false), "false")); @@ -1387,13 +1387,13 @@ fn boolToStr(b: bool) []const u8 { } test "cast f16 to wider types" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1408,12 +1408,12 @@ test "cast f16 to wider types" { } test "cast f128 to narrower types" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1428,10 +1428,10 @@ test "cast f128 to narrower types" { } test "peer type resolution: unreachable, null, slice" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest(num: usize, word: []const u8) !void { @@ -1447,8 +1447,8 @@ test "peer type resolution: unreachable, null, slice" { } test "cast i8 fn call peers to i32 result" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -1468,10 +1468,10 @@ test "cast i8 fn call peers to i32 result" { } test "cast compatible optional types" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: ?[:0]const u8 = null; var b: ?[]const u8 = a; @@ -1479,9 +1479,9 @@ test "cast compatible optional types" { } test "coerce undefined single-item pointer of array to error union of slice" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a = @as([*]u8, undefined)[0..0]; var b: error{a}![]const u8 = a; @@ -1490,20 +1490,20 @@ test "coerce undefined single-item pointer of array to error union of slice" { } test "pointer to empty struct literal to mutable slice" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: []i32 = &.{}; try expect(x.len == 0); } test "coerce between pointers of compatible differently-named floats" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/12396 @@ -1532,9 +1532,9 @@ test "peer type resolution of const and non-const pointer to array" { } test "intFromFloat to zero-bit int" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const a: f32 = 0.0; try comptime std.testing.expect(@as(u0, @intFromFloat(a)) == 0); @@ -1557,8 +1557,8 @@ test "cast typed undefined to int" { } test "implicit cast from [:0]T to [*c]T" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: [:0]const u8 = "foo"; var b: [*c]const u8 = a; @@ -1568,8 +1568,8 @@ test "implicit cast from [:0]T to [*c]T" { } test "bitcast packed struct with u0" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO const S = packed struct(u2) { a: u0, b: u2 }; const s = @as(S, @bitCast(@as(u2, 2))); @@ -1580,8 +1580,8 @@ test "bitcast packed struct with u0" { } test "optional pointer coerced to optional allowzero pointer" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var p: ?*u32 = undefined; var q: ?*allowzero u32 = undefined; @@ -1591,7 +1591,7 @@ test "optional pointer coerced to optional allowzero pointer" { } test "single item pointer to pointer to array to slice" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: i32 = 1234; try expect(@as([]const i32, @as(*[1]i32, &x))[0] == 1234); @@ -1600,8 +1600,8 @@ test "single item pointer to pointer to array to slice" { } test "peer type resolution forms error union" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo: i32 = 123; const result = if (foo < 0) switch (-foo) { @@ -1628,7 +1628,7 @@ test "@volatileCast without a result location" { } test "coercion from single-item pointer to @as to slice" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u32 = 1; @@ -1639,12 +1639,12 @@ test "coercion from single-item pointer to @as to slice" { } test "peer type resolution: const sentinel slice and mutable non-sentinel slice" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest(comptime T: type, comptime s: T) !void { @@ -1669,12 +1669,12 @@ test "peer type resolution: const sentinel slice and mutable non-sentinel slice" } test "peer type resolution: float and comptime-known fixed-width integer" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const i: u8 = 100; var f: f32 = 1.234; @@ -1692,12 +1692,12 @@ test "peer type resolution: float and comptime-known fixed-width integer" { } test "peer type resolution: same array type with sentinel" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var a: [2:0]u32 = .{ 0, 1 }; var b: [2:0]u32 = .{ 2, 3 }; @@ -1715,12 +1715,12 @@ test "peer type resolution: same array type with sentinel" { } test "peer type resolution: array with sentinel and array without sentinel" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var a: [2:0]u32 = .{ 0, 1 }; var b: [2]u32 = .{ 2, 3 }; @@ -1738,12 +1738,12 @@ test "peer type resolution: array with sentinel and array without sentinel" { } test "peer type resolution: array and vector with same child type" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var arr: [2]u32 = .{ 0, 1 }; var vec: @Vector(2, u32) = .{ 2, 3 }; @@ -1761,12 +1761,12 @@ test "peer type resolution: array and vector with same child type" { } test "peer type resolution: array with smaller child type and vector with larger child type" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var arr: [2]u8 = .{ 0, 1 }; var vec: @Vector(2, u64) = .{ 2, 3 }; @@ -1784,12 +1784,12 @@ test "peer type resolution: array with smaller child type and vector with larger } test "peer type resolution: error union and optional of same type" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const E = error{Foo}; var a: E!*u8 = error.Foo; @@ -1808,12 +1808,12 @@ test "peer type resolution: error union and optional of same type" { } test "peer type resolution: C pointer and @TypeOf(null)" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var a: [*c]c_int = 0x1000; const b = null; @@ -1831,12 +1831,12 @@ test "peer type resolution: C pointer and @TypeOf(null)" { } test "peer type resolution: three-way resolution combines error set and optional" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const E = error{Foo}; var a: E = error.Foo; @@ -1874,12 +1874,12 @@ test "peer type resolution: three-way resolution combines error set and optional } test "peer type resolution: vector and optional vector" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var a: ?@Vector(3, u32) = .{ 0, 1, 2 }; var b: @Vector(3, u32) = .{ 3, 4, 5 }; @@ -1897,12 +1897,12 @@ test "peer type resolution: vector and optional vector" { } test "peer type resolution: optional fixed-width int and comptime_int" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var a: ?i32 = 42; const b: comptime_int = 50; @@ -1920,12 +1920,12 @@ test "peer type resolution: optional fixed-width int and comptime_int" { } test "peer type resolution: array and tuple" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var arr: [3]i32 = .{ 1, 2, 3 }; const tup = .{ 4, 5, 6 }; @@ -1944,12 +1944,12 @@ test "peer type resolution: array and tuple" { } test "peer type resolution: vector and tuple" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var vec: @Vector(3, i32) = .{ 1, 2, 3 }; const tup = .{ 4, 5, 6 }; @@ -1968,12 +1968,12 @@ test "peer type resolution: vector and tuple" { } test "peer type resolution: vector and array and tuple" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var vec: @Vector(2, i8) = .{ 10, 20 }; var arr: [2]i8 = .{ 30, 40 }; @@ -2011,12 +2011,12 @@ test "peer type resolution: vector and array and tuple" { } test "peer type resolution: empty tuple pointer and slice" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var a: [:0]const u8 = "Hello"; var b = &.{}; @@ -2033,12 +2033,12 @@ test "peer type resolution: empty tuple pointer and slice" { } test "peer type resolution: tuple pointer and slice" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var a: [:0]const u8 = "Hello"; var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') }; @@ -2055,12 +2055,12 @@ test "peer type resolution: tuple pointer and slice" { } test "peer type resolution: tuple pointer and optional slice" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var a: ?[:0]const u8 = null; var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') }; @@ -2077,12 +2077,12 @@ test "peer type resolution: tuple pointer and optional slice" { } test "peer type resolution: many compatible pointers" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var buf = "foo-3".*; @@ -2144,12 +2144,12 @@ test "peer type resolution: many compatible pointers" { } test "peer type resolution: tuples with comptime fields" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const a = .{ 1, 2 }; const b = .{ @as(u32, 3), @as(i16, 4) }; @@ -2177,12 +2177,12 @@ test "peer type resolution: tuples with comptime fields" { } test "peer type resolution: C pointer and many pointer" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var buf = "hello".*; @@ -2201,12 +2201,12 @@ test "peer type resolution: C pointer and many pointer" { } test "peer type resolution: pointer attributes are combined correctly" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var buf_a align(4) = "foo".*; var buf_b align(4) = "bar".*; @@ -2246,12 +2246,12 @@ test "peer type resolution: pointer attributes are combined correctly" { } test "cast builtins can wrap result in optional" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { const MyEnum = enum(u32) { _ }; @@ -2286,12 +2286,12 @@ test "cast builtins can wrap result in optional" { } test "cast builtins can wrap result in error union" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { const MyEnum = enum(u32) { _ }; @@ -2327,12 +2327,12 @@ test "cast builtins can wrap result in error union" { } test "cast builtins can wrap result in error union and optional" { - if (builtin.zig_backend == .stage2_aarch64) 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 - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { const MyEnum = enum(u32) { _ }; diff --git a/test/behavior/cast_int.zig b/test/behavior/cast_int.zig index 09733d00a0a6..12fe38aa2363 100644 --- a/test/behavior/cast_int.zig +++ b/test/behavior/cast_int.zig @@ -4,10 +4,10 @@ const expect = std.testing.expect; const maxInt = std.math.maxInt; test "@intCast i32 to u7" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u128 = maxInt(u128); var y: i32 = 120; @@ -16,10 +16,10 @@ test "@intCast i32 to u7" { } test "coerce i8 to i32 and @intCast back" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: i8 = -5; var y: i32 = -5; diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig index 639de0f5f2b9..23df533669b6 100644 --- a/test/behavior/comptime_memory.zig +++ b/test/behavior/comptime_memory.zig @@ -75,8 +75,8 @@ fn bigToNativeEndian(comptime T: type, v: T) T { return if (endian == .Big) v else @byteSwap(v); } test "type pun endianness" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO comptime { const StructOfBytes = extern struct { x: [4]u8 }; @@ -376,8 +376,8 @@ test "offset field ptr by enclosing array element size" { } test "accessing reinterpreted memory of parent object" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = extern struct { a: f32, @@ -433,7 +433,7 @@ test "dereference undefined pointer to zero-bit type" { } test "type pun extern struct" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = extern struct { f: u8 }; comptime var s = S{ .f = 123 }; diff --git a/test/behavior/const_slice_child.zig b/test/behavior/const_slice_child.zig index 68c6863bcd81..e1afc4d0f983 100644 --- a/test/behavior/const_slice_child.zig +++ b/test/behavior/const_slice_child.zig @@ -7,10 +7,10 @@ const expect = testing.expect; var argv: [*]const [*]const u8 = undefined; test "const slice child" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const strs = [_][*]const u8{ "one", "two", "three" }; argv = &strs; diff --git a/test/behavior/defer.zig b/test/behavior/defer.zig index dd7ded911de9..1a1b713267bd 100644 --- a/test/behavior/defer.zig +++ b/test/behavior/defer.zig @@ -5,7 +5,7 @@ const expectEqual = std.testing.expectEqual; const expectError = std.testing.expectError; test "break and continue inside loop inside defer expression" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; testBreakContInDefer(10); comptime testBreakContInDefer(10); @@ -34,9 +34,9 @@ test "defer and labeled break" { } test "errdefer does not apply to fn inside fn" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (testNestedFnErrDefer()) |_| @panic("expected error") else |e| try expect(e == error.Bad); } @@ -53,9 +53,9 @@ fn testNestedFnErrDefer() anyerror!void { } test "return variable while defer expression in scope to modify it" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -94,10 +94,10 @@ fn runSomeErrorDefers(x: bool) !bool { } test "mixing normal and error defers" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(runSomeErrorDefers(true) catch unreachable); try expect(result[0] == 'c'); @@ -114,10 +114,10 @@ test "mixing normal and error defers" { } test "errdefer with payload" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo() !i32 { @@ -135,12 +135,12 @@ test "errdefer with payload" { } test "reference to errdefer payload" { - 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_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { fn foo() !i32 { @@ -161,9 +161,9 @@ test "reference to errdefer payload" { } test "simple else prong doesn't emit an error for unreachable else prong" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo() error{Foo}!void { diff --git a/test/behavior/empty_tuple_fields.zig b/test/behavior/empty_tuple_fields.zig index a7a3d27e02ae..da1ab09ec7c0 100644 --- a/test/behavior/empty_tuple_fields.zig +++ b/test/behavior/empty_tuple_fields.zig @@ -2,9 +2,9 @@ const std = @import("std"); const builtin = @import("builtin"); test "empty file level struct" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = @import("empty_file_level_struct.zig"); const info = @typeInfo(T); @@ -14,9 +14,9 @@ test "empty file level struct" { } test "empty file level union" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = @import("empty_file_level_union.zig"); const info = @typeInfo(T); diff --git a/test/behavior/empty_union.zig b/test/behavior/empty_union.zig index 1bdbf8e54b17..6a3cc6eb1bbd 100644 --- a/test/behavior/empty_union.zig +++ b/test/behavior/empty_union.zig @@ -9,7 +9,7 @@ test "switch on empty enum" { } test "switch on empty enum with a specified tag type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const E = enum(u8) {}; var e: E = undefined; @@ -17,8 +17,8 @@ test "switch on empty enum with a specified tag type" { } test "switch on empty auto numbered tagged union" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union(enum(u8)) {}; var u: U = undefined; @@ -26,7 +26,7 @@ test "switch on empty auto numbered tagged union" { } test "switch on empty tagged union" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO const E = enum {}; const U = union(E) {}; @@ -47,7 +47,7 @@ test "empty extern union" { } test "empty union passed as argument" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union(enum) { fn f(u: @This()) void { @@ -58,7 +58,7 @@ test "empty union passed as argument" { } test "empty enum passed as argument" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const E = enum { fn f(e: @This()) void { diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig index a472dc87a400..e3793c4f9497 100644 --- a/test/behavior/enum.zig +++ b/test/behavior/enum.zig @@ -25,8 +25,8 @@ fn testIntToEnumEval(x: i32) !void { const IntToEnumNumber = enum { Zero, One, Two, Three, Four }; test "int to enum" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testIntToEnumEval(3); } @@ -607,17 +607,17 @@ fn testEnumWithSpecifiedTagValues(x: MultipleChoice) !void { } test "enum with specified tag values" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testEnumWithSpecifiedTagValues(MultipleChoice.C); try comptime testEnumWithSpecifiedTagValues(MultipleChoice.C); } test "non-exhaustive enum" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const E = enum(u8) { a, b, _ }; @@ -660,7 +660,7 @@ test "non-exhaustive enum" { } test "empty non-exhaustive enum" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const E = enum(u8) { _ }; @@ -681,9 +681,9 @@ test "empty non-exhaustive enum" { } test "single field non-exhaustive enum" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const E = enum(u8) { a, _ }; @@ -746,8 +746,8 @@ test "cast integer literal to enum" { } test "enum with specified and unspecified tag values" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D); try comptime testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D); @@ -856,7 +856,7 @@ fn doALoopThing(id: EnumWithOneMember) void { } test "comparison operator on enum with one member is comptime-known" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; doALoopThing(EnumWithOneMember.Eof); } @@ -907,9 +907,9 @@ test "enum value allocation" { } test "enum literal casting to tagged union" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const Arch = union(enum) { x86_64, @@ -933,9 +933,9 @@ test "enum literal casting to tagged union" { const Bar = enum { A, B, C, D }; test "enum literal casting to error union with payload enum" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var bar: error{B}!Bar = undefined; bar = .B; // should never cast to the error set @@ -944,10 +944,10 @@ test "enum literal casting to error union with payload enum" { } test "constant enum initialization with differing sizes" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try test3_1(test3_foo); try test3_2(test3_bar); @@ -987,10 +987,10 @@ fn test3_2(f: Test3Foo) !void { } test "@tagName" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); try comptime expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); @@ -1003,10 +1003,10 @@ fn testEnumTagNameBare(n: anytype) []const u8 { const BareNumber = enum { One, Two, Three }; test "@tagName non-exhaustive enum" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); try comptime expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); @@ -1014,10 +1014,10 @@ test "@tagName non-exhaustive enum" { const NonExhaustive = enum(u8) { A, B, _ }; test "@tagName is null-terminated" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest(n: BareNumber) !void { @@ -1029,10 +1029,10 @@ test "@tagName is null-terminated" { } test "tag name with assigned enum values" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const LocalFoo = enum(u8) { A = 1, @@ -1043,18 +1043,18 @@ test "tag name with assigned enum values" { } test "@tagName on enum literals" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); try comptime expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); } test "enum literal casting to optional" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var bar: ?Bar = undefined; bar = .B; @@ -1079,10 +1079,10 @@ const bit_field_1 = BitFieldOfEnums{ }; test "bit field access with enum fields" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var data = bit_field_1; try expect(getA(&data) == A.Two); @@ -1119,10 +1119,10 @@ test "enum literal in array literal" { } test "tag name functions are unique" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { const E = enum { a, b }; @@ -1139,9 +1139,9 @@ test "tag name functions are unique" { } test "size of enum with only one tag which has explicit integer tag type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const E = enum(u8) { nope = 10 }; const S0 = struct { e: E }; @@ -1199,7 +1199,7 @@ test "enum tag from a local variable" { } test "auto-numbered enum with signed tag type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const E = enum(i32) { a, b }; diff --git a/test/behavior/error.zig b/test/behavior/error.zig index 4f26c9b18c8a..eb79a148b57a 100644 --- a/test/behavior/error.zig +++ b/test/behavior/error.zig @@ -29,8 +29,8 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void { } test "error binary operator" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a = errBinaryOperatorG(true) catch 3; const b = errBinaryOperatorG(false) catch 3; @@ -61,15 +61,15 @@ pub fn baz() anyerror!i32 { } test "error wrapping" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect((baz() catch unreachable) == 15); } test "unwrap simple value from error" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const i = unwrapSimpleValueFromErrorDo() catch unreachable; try expect(i == 13); @@ -79,8 +79,8 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize { } test "error return in assignment" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; doErrReturnInAssignment() catch unreachable; } @@ -101,9 +101,9 @@ test "syntax: optional operator in front of error union operator" { } test "widen cast integer payload of error union function call" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn errorable() !u64 { @@ -119,8 +119,8 @@ test "widen cast integer payload of error union function call" { } test "debug info for optional error set" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const SomeError = error{ Hello, Hello2 }; var a_local_variable: ?SomeError = null; @@ -128,8 +128,8 @@ test "debug info for optional error set" { } test "implicit cast to optional to error union to return result loc" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn entry() !void { @@ -150,13 +150,13 @@ test "implicit cast to optional to error union to return result loc" { } test "fn returning empty error set can be passed as fn returning any error" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; entry(); comptime entry(); } test "fn returning empty error set can be passed as fn returning any error - pointer" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; entryPtr(); comptime entryPtr(); } @@ -223,8 +223,8 @@ fn testErrorSetType() !void { } test "explicit error set cast" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testExplicitErrorSetCast(Set1.A); try comptime testExplicitErrorSetCast(Set1.A); @@ -242,8 +242,8 @@ fn testExplicitErrorSetCast(set1: Set1) !void { } test "comptime test error for empty error set" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testComptimeTestErrorEmptySet(1234); try comptime testComptimeTestErrorEmptySet(1234); @@ -279,7 +279,7 @@ test "inferred empty error set comptime catch" { } test "error inference with an empty set" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Struct = struct { pub fn func() (error{})!usize { @@ -301,8 +301,8 @@ test "error inference with an empty set" { } test "error union peer type resolution" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testErrorUnionPeerTypeResolution(1); } @@ -333,8 +333,8 @@ fn quux_1() !i32 { } test "error: Zero sized error set returned with value payload crash" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; _ = try foo3(0); _ = try comptime foo3(0); @@ -346,8 +346,8 @@ fn foo3(b: usize) Error!usize { } test "error: Infer error set from literals" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; _ = nullLiteral("n") catch |err| handleErrors(err); _ = floatLiteral("n") catch |err| handleErrors(err); @@ -384,10 +384,10 @@ fn intLiteral(str: []const u8) !?i64 { } test "nested error union function call in optional unwrap" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Foo = struct { @@ -432,9 +432,9 @@ test "nested error union function call in optional unwrap" { } test "return function call to error set from error union function" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn errorable() anyerror!i32 { @@ -450,10 +450,10 @@ test "return function call to error set from error union function" { } test "optional error set is the same size as error set" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime expect(@sizeOf(?anyerror) == @sizeOf(anyerror)); try comptime expect(@alignOf(?anyerror) == @alignOf(anyerror)); @@ -467,9 +467,9 @@ test "optional error set is the same size as error set" { } test "nested catch" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn entry() !void { @@ -493,8 +493,8 @@ test "nested catch" { } test "function pointer with return type that is error union with payload which is pointer of parent struct" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Foo = struct { @@ -517,10 +517,10 @@ test "function pointer with return type that is error union with payload which i } test "return result loc as peer result loc in inferred error set function" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -549,10 +549,10 @@ test "return result loc as peer result loc in inferred error set function" { } test "error payload type is correctly resolved" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const MyIntWrapper = struct { const Self = @This(); @@ -579,10 +579,10 @@ test "error union comptime caching" { } test "@errorName" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, @errorName(error.AnError), "AnError")); try expect(mem.eql(u8, @errorName(error.ALongerErrorName), "ALongerErrorName")); @@ -593,10 +593,10 @@ fn gimmeItBroke() anyerror { } test "@errorName sentinel length matches slice length" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const name = testBuiltinErrorName(error.FooBar); const length: usize = 6; @@ -624,7 +624,7 @@ test "error set equality" { } test "inferred error set equality" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn foo() !void { @@ -670,7 +670,7 @@ test "peer type resolution of two different error unions" { } test "coerce error set to the current inferred error set" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo() !void { var a = false; @@ -686,10 +686,10 @@ test "coerce error set to the current inferred error set" { } test "error union payload is properly aligned" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { a: u128, @@ -704,8 +704,8 @@ test "error union payload is properly aligned" { } test "ret_ptr doesn't cause own inferred error set to be resolved" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn foo() !void {} @@ -720,8 +720,8 @@ test "ret_ptr doesn't cause own inferred error set to be resolved" { } test "simple else prong allowed even when all errors handled" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo() !u8 { @@ -746,10 +746,10 @@ test "simple else prong allowed even when all errors handled" { } test "pointer to error union payload" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var err_union: anyerror!u8 = 15; @@ -779,10 +779,10 @@ const NoReturn = struct { }; test "error union of noreturn used with if" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; NoReturn.a = 64; if (NoReturn.loop()) { @@ -793,10 +793,10 @@ test "error union of noreturn used with if" { } test "error union of noreturn used with try" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; NoReturn.a = 64; const err = NoReturn.testTry(); @@ -804,10 +804,10 @@ test "error union of noreturn used with try" { } test "error union of noreturn used with catch" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; NoReturn.a = 64; const err = NoReturn.testCatch(); @@ -815,10 +815,10 @@ test "error union of noreturn used with catch" { } test "alignment of wrapping an error union payload" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const I = extern struct { x: i128 }; @@ -832,8 +832,8 @@ test "alignment of wrapping an error union payload" { } test "compare error union and error set" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: anyerror = error.Foo; var b: anyerror!u32 = error.Bar; @@ -862,16 +862,16 @@ fn non_errorable() void { } test "catch within a function that calls no errorable functions" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; non_errorable(); } test "error from comptime string" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const name = "Weird error name!"; const S = struct { @@ -893,9 +893,9 @@ test "field access of anyerror results in smaller error set" { } test "optional error union return type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo() ?anyerror!u32 { @@ -907,9 +907,9 @@ test "optional error union return type" { } test "optional error set return type" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const E = error{ A, B }; const S = struct { @@ -923,9 +923,9 @@ test "optional error set return type" { } test "returning an error union containing a type with no runtime bits" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const ZeroByteType = struct { foo: void, @@ -940,8 +940,8 @@ test "returning an error union containing a type with no runtime bits" { } test "try used in recursive function with inferred error set" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO const Value = union(enum) { values: []const @This(), diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig index 35cfab9211fc..e0a240f21386 100644 --- a/test/behavior/eval.zig +++ b/test/behavior/eval.zig @@ -5,7 +5,7 @@ const expect = std.testing.expect; const expectEqual = std.testing.expectEqual; test "compile time recursion" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(some_data.len == 21); } @@ -20,9 +20,9 @@ fn unwrapAndAddOne(blah: ?i32) i32 { } const should_be_1235 = unwrapAndAddOne(1234); test "static add one" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(should_be_1235 == 1235); } @@ -72,9 +72,9 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 { } test "constant expressions" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var array: [array_size]u8 = undefined; try expect(@sizeOf(@TypeOf(array)) == 20); @@ -94,8 +94,8 @@ fn letsTryToCompareBools(a: bool, b: bool) bool { return max(bool, a, b); } test "inlined block and runtime block phi" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(letsTryToCompareBools(true, true)); try expect(letsTryToCompareBools(true, false)); @@ -141,9 +141,9 @@ test "pointer to type" { } test "a type constructed in a global expression" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var l: List = undefined; l.array[0] = 10; @@ -202,7 +202,7 @@ test "@setEvalBranchQuota" { } test "constant struct with negation" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(vertices[0].x == @as(f32, -0.6)); } @@ -238,8 +238,8 @@ const vertices = [_]Vertex{ }; test "statically initialized list" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(static_point_list[0].x == 1); try expect(static_point_list[0].y == 2); @@ -308,7 +308,7 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 { } test "comptime iterate over fn ptr list" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(performFn('t', 1) == 6); try expect(performFn('o', 0) == 1); @@ -346,9 +346,9 @@ fn doesAlotT(comptime T: type, value: usize) T { } test "@setEvalBranchQuota at same scope as generic function call" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(doesAlotT(u32, 2) == 2); } @@ -385,7 +385,7 @@ test "zero extend from u0 to u1" { } test "return 0 from function that has u0 return type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo_zero() u0 { @@ -400,9 +400,9 @@ test "return 0 from function that has u0 return type" { } test "statically initialized struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; st_init_str_foo.x += 1; try expect(st_init_str_foo.x == 14); @@ -417,7 +417,7 @@ var st_init_str_foo = StInitStrFoo{ }; test "inline for with same type but different values" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var res: usize = 0; inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| { @@ -451,10 +451,10 @@ fn copyWithPartialInline(s: []u32, b: []u8) void { } test "binary math operator in partially inlined function" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var s: [4]u32 = undefined; var b: [16]u8 = undefined; @@ -470,10 +470,10 @@ test "binary math operator in partially inlined function" { } test "comptime shl" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: u128 = 3; var b: u7 = 63; @@ -499,8 +499,8 @@ test "comptime bitwise operators" { } test "comptime shlWithOverflow" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0]; var a = ~@as(u64, 0); @@ -510,9 +510,9 @@ test "comptime shlWithOverflow" { } test "const ptr to variable data changes at runtime" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(foo_ref.name[0] == 'a'); foo_ref.name = "b"; @@ -527,13 +527,13 @@ var foo_contents = Foo{ .name = "a" }; const foo_ref = &foo_contents; test "runtime 128 bit integer division" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; var a: u128 = 152313999999999991610955792383; var b: u128 = 10000000000000000000; @@ -542,19 +542,19 @@ test "runtime 128 bit integer division" { } test "@tagName of @typeInfo" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const str = @tagName(@typeInfo(u8)); try expect(std.mem.eql(u8, str, "Int")); } test "static eval list init" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(static_vec3.data[2] == 1.0); try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0); @@ -570,7 +570,7 @@ pub fn vec3(x: f32, y: f32, z: f32) Vec3 { } test "inlined loop has array literal with elided runtime scope on first iteration but not second iteration" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var runtime = [1]i32{3}; comptime var i: usize = 0; @@ -584,9 +584,9 @@ test "inlined loop has array literal with elided runtime scope on first iteratio } test "ptr to local array argument at comptime" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { var bytes: [10]u8 = undefined; @@ -622,8 +622,8 @@ fn testCompTimeUIntComparisons(x: u32) void { const hi1 = "hi"; const hi2 = hi1; test "const global shares pointer with other same one" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try assertEqualPtrs(&hi1[0], &hi2[0]); try comptime expect(&hi1[0] == &hi2[0]); @@ -659,7 +659,7 @@ pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type { } test "comptime function with mutable pointer is not memoized" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { var x: i32 = 1; @@ -749,20 +749,20 @@ test "*align(1) u16 is the same as *align(1:0:2) u16" { } test "array concatenation of function calls" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a = oneItem(3) ++ oneItem(4); try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 })); } test "array multiplication of function calls" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a = oneItem(3) ** scalar(2); try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 })); @@ -777,10 +777,10 @@ fn scalar(x: u32) u32 { } test "array concatenation peer resolves element types - value" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a = [2]u3{ 1, 7 }; var b = [3]u8{ 200, 225, 255 }; @@ -794,10 +794,10 @@ test "array concatenation peer resolves element types - value" { } test "array concatenation peer resolves element types - pointer" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a = [2]u3{ 1, 7 }; var b = [3]u8{ 200, 225, 255 }; @@ -811,10 +811,10 @@ test "array concatenation peer resolves element types - pointer" { } test "array concatenation sets the sentinel - value" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a = [2]u3{ 1, 7 }; var b = [3:69]u8{ 200, 225, 255 }; @@ -830,9 +830,9 @@ test "array concatenation sets the sentinel - value" { } test "array concatenation sets the sentinel - pointer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a = [2]u3{ 1, 7 }; var b = [3:69]u8{ 200, 225, 255 }; @@ -848,10 +848,10 @@ test "array concatenation sets the sentinel - pointer" { } test "array multiplication sets the sentinel - value" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a = [2:7]u3{ 1, 6 }; var b = a ** 2; @@ -865,10 +865,10 @@ test "array multiplication sets the sentinel - value" { } test "array multiplication sets the sentinel - pointer" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a = [2:7]u3{ 1, 6 }; var b = &a ** 2; @@ -891,9 +891,9 @@ test "comptime assign int to optional int" { } test "two comptime calls with array default initialized to undefined" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { const CrossTarget = struct { @@ -977,8 +977,8 @@ test "const local with comptime init through array init" { } test "closure capture type of runtime-known parameter" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn b(c: anytype) !void { @@ -992,8 +992,8 @@ test "closure capture type of runtime-known parameter" { } test "comptime break passing through runtime condition converted to runtime break" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1024,10 +1024,10 @@ test "comptime break passing through runtime condition converted to runtime brea } test "comptime break to outer loop passing through runtime condition converted to runtime break" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1077,8 +1077,8 @@ test "comptime break operand passing through runtime condition converted to runt } test "comptime break operand passing through runtime switch converted to runtime break" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest(runtime: u8) !void { @@ -1097,9 +1097,9 @@ test "comptime break operand passing through runtime switch converted to runtime } test "no dependency loop for alignment of self struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1135,9 +1135,9 @@ test "no dependency loop for alignment of self struct" { } test "no dependency loop for alignment of self bare union" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1173,9 +1173,9 @@ test "no dependency loop for alignment of self bare union" { } test "no dependency loop for alignment of self tagged union" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1216,10 +1216,10 @@ test "equality of pointers to comptime const" { } test "storing an array of type in a field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() void { @@ -1246,9 +1246,9 @@ test "storing an array of type in a field" { } test "pass pointer to field of comptime-only type as a runtime parameter" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Mixed = struct { @@ -1363,10 +1363,10 @@ test "lazy sizeof is resolved in division" { } test "lazy value is resolved as slice operand" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const A = struct { a: u32 }; var a: [512]u64 = undefined; @@ -1423,8 +1423,8 @@ test "inline for inside a runtime condition" { } test "continue in inline for inside a comptime switch" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const arr = .{ 1, 2, 3 }; var count: u8 = 0; @@ -1489,8 +1489,8 @@ test "continue nested inline for loop in named block expr" { } test "x and false is comptime-known false" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = struct { var x: u32 = 0; @@ -1517,8 +1517,8 @@ test "x and false is comptime-known false" { } test "x or true is comptime-known true" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = struct { var x: u32 = 0; @@ -1545,10 +1545,10 @@ test "x or true is comptime-known true" { } test "non-optional and optional array elements concatenated" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const array = [1]u8{'A'} ++ [1]?u8{null}; var index: usize = 0; @@ -1579,7 +1579,7 @@ test "comptime function turns function value to function pointer" { } test "container level const and var have unique addresses" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { x: i32, @@ -1637,7 +1637,7 @@ test "result of nested switch assigned to variable" { } test "inline for loop of functions returning error unions" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T1 = struct { fn v() error{}!usize { @@ -1692,7 +1692,7 @@ test "early exit in container level const" { } test "@inComptime" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn inComptime() bool { diff --git a/test/behavior/export.zig b/test/behavior/export.zig index 4751ccafe58c..a26a47ecc6c0 100644 --- a/test/behavior/export.zig +++ b/test/behavior/export.zig @@ -22,7 +22,7 @@ const PackedUnion = packed union { }; test "packed struct, enum, union parameters in extern function" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO testPackedStuff(&(PackedStruct{ .a = 1, diff --git a/test/behavior/field_parent_ptr.zig b/test/behavior/field_parent_ptr.zig index 6e3eda9032ca..4583bce3c6ec 100644 --- a/test/behavior/field_parent_ptr.zig +++ b/test/behavior/field_parent_ptr.zig @@ -2,18 +2,18 @@ const expect = @import("std").testing.expect; const builtin = @import("builtin"); test "@fieldParentPtr non-first field" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testParentFieldPtr(&foo.c); try comptime testParentFieldPtr(&foo.c); } test "@fieldParentPtr first field" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testParentFieldPtrFirst(&foo.a); try comptime testParentFieldPtrFirst(&foo.a); @@ -50,10 +50,10 @@ fn testParentFieldPtrFirst(a: *const bool) !void { } test "@fieldParentPtr untagged union" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testFieldParentPtrUnion(&bar.c); try comptime testFieldParentPtrUnion(&bar.c); @@ -77,10 +77,10 @@ fn testFieldParentPtrUnion(c: *const i32) !void { } test "@fieldParentPtr tagged union" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testFieldParentPtrTaggedUnion(&bar_tagged.c); try comptime testFieldParentPtrTaggedUnion(&bar_tagged.c); @@ -104,10 +104,10 @@ fn testFieldParentPtrTaggedUnion(c: *const i32) !void { } test "@fieldParentPtr extern union" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testFieldParentPtrExternUnion(&bar_extern.c); try comptime testFieldParentPtrExternUnion(&bar_extern.c); diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig index 6825dccf8683..a84a743ab8b1 100644 --- a/test/behavior/floatop.zig +++ b/test/behavior/floatop.zig @@ -8,7 +8,7 @@ const has_f80_rt = switch (builtin.cpu.arch) { .x86_64, .x86 => true, else => false, }; -const no_x86_64_hardware_f16_support = builtin.zig_backend == .stage2_x86_64 and +const no_x86_64_hardware_f16_support = builtin.zig_backend == .zsf_x86_64 and !std.Target.x86.featureSetHas(builtin.cpu.features, .f16c); const epsilon_16 = 0.001; @@ -22,7 +22,7 @@ fn epsForType(comptime T: type) T { } test "floating point comparisons" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testFloatComparisons(); try comptime testFloatComparisons(); @@ -55,10 +55,10 @@ fn testFloatComparisons() !void { test "different sized float comparisons" { if (no_x86_64_hardware_f16_support) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testDifferentSizedFloatComparisons(); try comptime testDifferentSizedFloatComparisons(); @@ -90,8 +90,8 @@ fn testDifferentSizedFloatComparisons() !void { //} test "negative f128 intFromFloat at compile-time" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const a: f128 = -2; var b = @as(i64, @intFromFloat(a)); @@ -99,10 +99,10 @@ test "negative f128 intFromFloat at compile-time" { } test "@sqrt" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testSqrt(); try testSqrt(); @@ -137,10 +137,10 @@ fn testSqrt() !void { } test "@sqrt with vectors" { - if (builtin.zig_backend == .stage2_wasm) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testSqrtWithVectors(); try testSqrtWithVectors(); @@ -157,10 +157,10 @@ fn testSqrtWithVectors() !void { test "more @sqrt f16 tests" { if (no_x86_64_hardware_f16_support) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO these are not all passing at comptime try expect(@sqrt(@as(f16, 0.0)) == 0.0); @@ -182,10 +182,10 @@ test "more @sqrt f16 tests" { } test "another, possibly redundant @sqrt test" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO if (no_x86_64_hardware_f16_support) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testSqrtLegacy(f64, 12.0); try comptime testSqrtLegacy(f64, 12.0); @@ -209,10 +209,10 @@ fn testSqrtLegacy(comptime T: type, x: T) !void { test "@sin" { if (no_x86_64_hardware_f16_support) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testSin(); try testSin(); @@ -229,11 +229,11 @@ fn testSin() !void { } test "@sin with vectors" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testSinWithVectors(); try testSinWithVectors(); @@ -250,10 +250,10 @@ fn testSinWithVectors() !void { test "@cos" { if (no_x86_64_hardware_f16_support) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testCos(); try testCos(); @@ -270,11 +270,11 @@ fn testCos() !void { } test "@cos with vectors" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testCosWithVectors(); try testCosWithVectors(); @@ -291,10 +291,10 @@ fn testCosWithVectors() !void { test "@exp" { if (no_x86_64_hardware_f16_support) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testExp(); try testExp(); @@ -310,11 +310,11 @@ fn testExp() !void { } test "@exp with vectors" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testExpWithVectors(); try testExpWithVectors(); @@ -331,10 +331,10 @@ fn testExpWithVectors() !void { test "@exp2" { if (no_x86_64_hardware_f16_support) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testExp2(); try testExp2(); @@ -350,11 +350,11 @@ fn testExp2() !void { } test "@exp2 with @vectors" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testExp2WithVectors(); try testExp2WithVectors(); @@ -370,11 +370,11 @@ fn testExp2WithVectors() !void { } test "@log" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testLog(); try testLog(); @@ -401,12 +401,12 @@ fn testLog() !void { } test "@log with @vectors" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; @@ -420,10 +420,10 @@ test "@log with @vectors" { test "@log2" { if (no_x86_64_hardware_f16_support) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testLog2(); try testLog2(); @@ -439,13 +439,13 @@ fn testLog2() !void { } test "@log2 with vectors" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/13681 - if (builtin.zig_backend == .stage2_llvm and + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest; @@ -464,10 +464,10 @@ fn testLog2WithVectors() !void { test "@log10" { if (no_x86_64_hardware_f16_support) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testLog10(); try testLog10(); @@ -483,11 +483,11 @@ fn testLog10() !void { } test "@log10 with vectors" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testLog10WithVectors(); try testLog10WithVectors(); @@ -503,9 +503,9 @@ fn testLog10WithVectors() !void { } test "@fabs" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try comptime testFabs(); try testFabs(); @@ -530,10 +530,10 @@ fn testFabs() !void { } test "@fabs with vectors" { - if (builtin.zig_backend == .stage2_wasm) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testFabsWithVectors(); try testFabsWithVectors(); @@ -549,12 +549,12 @@ fn testFabsWithVectors() !void { } test "another, possibly redundant, @fabs test" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; try testFabsLegacy(f128, 12.0); try comptime testFabsLegacy(f128, 12.0); @@ -572,12 +572,12 @@ test "another, possibly redundant, @fabs test" { } test "@fabs f80" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; try testFabsLegacy(f80, 12.0); try comptime testFabsLegacy(f80, 12.0); @@ -590,12 +590,12 @@ fn testFabsLegacy(comptime T: type, x: T) !void { } test "a third @fabs test, surely there should not be three fabs tests" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) |T| { // normals @@ -620,9 +620,9 @@ test "a third @fabs test, surely there should not be three fabs tests" { } test "@floor" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try comptime testFloor(); try testFloor(); @@ -642,12 +642,12 @@ fn testFloor() !void { } test "@floor with vectors" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64 and !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testFloorWithVectors(); try testFloorWithVectors(); @@ -663,10 +663,10 @@ fn testFloorWithVectors() !void { } test "another, possibly redundant, @floor test" { - 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testFloorLegacy(f64, 12.0); try comptime testFloorLegacy(f64, 12.0); @@ -682,14 +682,14 @@ test "another, possibly redundant, @floor test" { } test "@floor f80" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; - - if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) { + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + + if (builtin.zig_backend == .zsf_llvm and builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/12602 return error.SkipZigTest; } @@ -699,12 +699,12 @@ test "@floor f80" { } test "@floor f128" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; try testFloorLegacy(f128, 12.0); try comptime testFloorLegacy(f128, 12.0); @@ -717,10 +717,10 @@ fn testFloorLegacy(comptime T: type, x: T) !void { } test "@ceil" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testCeil(); try testCeil(); @@ -740,12 +740,12 @@ fn testCeil() !void { } test "@ceil with vectors" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64 and !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testCeilWithVectors(); try testCeilWithVectors(); @@ -761,10 +761,10 @@ fn testCeilWithVectors() !void { } test "another, possibly redundant, @ceil test" { - 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testCeilLegacy(f64, 12.0); try comptime testCeilLegacy(f64, 12.0); @@ -780,14 +780,14 @@ test "another, possibly redundant, @ceil test" { } test "@ceil f80" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; - - if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) { + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + + if (builtin.zig_backend == .zsf_llvm and builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/12602 return error.SkipZigTest; } @@ -797,12 +797,12 @@ test "@ceil f80" { } test "@ceil f128" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; try testCeilLegacy(f128, 12.0); try comptime testCeilLegacy(f128, 12.0); @@ -815,9 +815,9 @@ fn testCeilLegacy(comptime T: type, x: T) !void { } test "@trunc" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try comptime testTrunc(); try testTrunc(); @@ -837,12 +837,12 @@ fn testTrunc() !void { } test "@trunc with vectors" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64 and !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testTruncWithVectors(); try testTruncWithVectors(); @@ -858,10 +858,10 @@ fn testTruncWithVectors() !void { } test "another, possibly redundant, @trunc test" { - 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testTruncLegacy(f64, 12.0); try comptime testTruncLegacy(f64, 12.0); @@ -877,14 +877,14 @@ test "another, possibly redundant, @trunc test" { } test "@trunc f80" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; - - if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) { + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + + if (builtin.zig_backend == .zsf_llvm and builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/12602 return error.SkipZigTest; } @@ -900,12 +900,12 @@ test "@trunc f80" { } test "@trunc f128" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; try testTruncLegacy(f128, 12.0); try comptime testTruncLegacy(f128, 12.0); @@ -927,10 +927,10 @@ fn testTruncLegacy(comptime T: type, x: T) !void { test "negation f16" { if (no_x86_64_hardware_f16_support) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (builtin.os.tag == .freebsd) { // TODO file issue to track this failure @@ -952,10 +952,10 @@ test "negation f16" { } test "negation f32" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -972,10 +972,10 @@ test "negation f32" { } test "negation f64" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -992,12 +992,12 @@ test "negation f64" { } test "negation f80" { - 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_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1014,12 +1014,12 @@ test "negation f80" { } test "negation f128" { - 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_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1036,9 +1036,9 @@ test "negation f128" { } test "eval @setFloatMode at compile-time" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const result = comptime fnWithFloatMode(); try expect(result == 1234.0); @@ -1059,12 +1059,12 @@ test "f128 at compile time is lossy" { } test "comptime fixed-width float zero divided by zero produces NaN" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; inline for (.{ f16, f32, f64, f80, f128 }) |F| { try expect(math.isNan(@as(F, 0) / @as(F, 0))); @@ -1072,11 +1072,11 @@ test "comptime fixed-width float zero divided by zero produces NaN" { } test "comptime fixed-width float non-zero divided by zero produces signed Inf" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; inline for (.{ f16, f32, f64, f80, f128 }) |F| { const pos = @as(F, 1) / @as(F, 0); @@ -1093,10 +1093,10 @@ test "comptime_float zero divided by zero produces zero" { } test "nan negation f16" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const nan_comptime = comptime math.nan(f16); const neg_nan_comptime = -nan_comptime; @@ -1112,10 +1112,10 @@ test "nan negation f16" { } test "nan negation f32" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const nan_comptime = comptime math.nan(f32); const neg_nan_comptime = -nan_comptime; @@ -1131,11 +1131,11 @@ test "nan negation f32" { } test "nan negation f64" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const nan_comptime = comptime math.nan(f64); const neg_nan_comptime = -nan_comptime; @@ -1151,11 +1151,11 @@ test "nan negation f64" { } test "nan negation f128" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const nan_comptime = comptime math.nan(f128); const neg_nan_comptime = -nan_comptime; @@ -1171,12 +1171,12 @@ test "nan negation f128" { } test "nan negation f80" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const nan_comptime = comptime math.nan(f80); const neg_nan_comptime = -nan_comptime; diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig index 1a5becc6b08b..0a5b5b02f6db 100644 --- a/test/behavior/fn.zig +++ b/test/behavior/fn.zig @@ -20,7 +20,7 @@ fn testLocVars(b: i32) void { } test "mutable local variables" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var zero: i32 = 0; try expect(zero == 0); @@ -53,7 +53,7 @@ test "weird function name" { } test "assign inline fn to const variable" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a = inlineFn; a(); @@ -72,16 +72,16 @@ fn outer(y: u32) *const fn (u32) u32 { } test "return inner function which references comptime variable of outer function" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var func = outer(10); try expect(func(3) == 7); } test "discard the result of a function that returns a struct" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn entry() void { @@ -102,10 +102,10 @@ test "discard the result of a function that returns a struct" { } test "inline function call that calls optional function pointer, return pointer at callsite interacts correctly with callsite return type" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { field: u32, @@ -150,9 +150,9 @@ fn fnWithUnreachable() noreturn { } test "extern struct with stdcallcc fn pointer" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and builtin.cpu.arch == .x86) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and builtin.cpu.arch == .x86) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = extern struct { ptr: *const fn () callconv(if (builtin.target.cpu.arch == .x86) .Stdcall else .C) i32, @@ -180,17 +180,17 @@ fn fComplexCallconvRet(x: u32) callconv(blk: { } test "function with complex callconv and return type expressions" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(fComplexCallconvRet(3).x == 9); } test "pass by non-copying value" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3); } @@ -205,8 +205,8 @@ fn addPointCoords(pt: Point) i32 { } test "pass by non-copying value through var arg" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3); } @@ -217,8 +217,8 @@ fn addPointCoordsVar(pt: anytype) !i32 { } test "pass by non-copying value as method" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var pt = Point2{ .x = 1, .y = 2 }; try expect(pt.addPointCoords() == 3); @@ -234,8 +234,8 @@ const Point2 = struct { }; test "pass by non-copying value as method, which is generic" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var pt = Point3{ .x = 1, .y = 2 }; try expect(pt.addPointCoords(i32) == 3); @@ -252,8 +252,8 @@ const Point3 = struct { }; test "pass by non-copying value as method, at comptime" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { var pt = Point2{ .x = 1, .y = 2 }; @@ -262,10 +262,10 @@ test "pass by non-copying value as method, at comptime" { } test "implicit cast fn call result to optional in field result" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn entry() !void { @@ -290,9 +290,9 @@ test "implicit cast fn call result to optional in field result" { } test "void parameters" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try voidFun(1, void{}, 2, {}); } @@ -305,7 +305,7 @@ fn voidFun(a: i32, b: void, c: i32, d: void) !void { } test "call function with empty string" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO acceptsString(""); } @@ -315,10 +315,10 @@ fn acceptsString(foo: []u8) void { } test "function pointers" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const fns = [_]*const @TypeOf(fn1){ &fn1, @@ -353,10 +353,10 @@ fn numberLiteralArg(a: anytype) !void { } test "function call with anon list literal" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -374,10 +374,10 @@ test "function call with anon list literal" { } test "function call with anon list literal - 2D" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -396,7 +396,7 @@ test "function call with anon list literal - 2D" { } test "ability to give comptime types and non comptime types to same parameter" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -415,7 +415,7 @@ test "ability to give comptime types and non comptime types to same parameter" { } test "function with inferred error set but returning no error" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo() !void {} @@ -426,8 +426,8 @@ test "function with inferred error set but returning no error" { } test "import passed byref to function in return type" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn get() @import("std").ArrayListUnmanaged(i32) { @@ -440,11 +440,11 @@ test "import passed byref to function in return type" { } test "implicit cast function to function ptr" { - 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_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S1 = struct { export fn someFunctionThatReturnsAValue() c_int { @@ -461,9 +461,9 @@ test "implicit cast function to function ptr" { } test "method call with optional and error union first param" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { x: i32 = 1234, @@ -481,9 +481,9 @@ test "method call with optional and error union first param" { } test "method call with optional pointer first param" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { x: i32 = 1234, @@ -499,10 +499,10 @@ test "method call with optional pointer first param" { } test "using @ptrCast on function pointers" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const A = struct { data: [4]u8 }; @@ -539,8 +539,8 @@ test "function returns function returning type" { } test "peer type resolution of inferred error set with non-void payload" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn openDataFile(mode: enum { read, write }) !u32 { diff --git a/test/behavior/fn_delegation.zig b/test/behavior/fn_delegation.zig index 95dbfeb4b2b7..f0f0d62b8057 100644 --- a/test/behavior/fn_delegation.zig +++ b/test/behavior/fn_delegation.zig @@ -32,8 +32,8 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 { } test "fn delegation" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const foo = Foo{}; try expect(foo.one() == 11); diff --git a/test/behavior/for.zig b/test/behavior/for.zig index 35f51da21816..51918993e301 100644 --- a/test/behavior/for.zig +++ b/test/behavior/for.zig @@ -5,9 +5,9 @@ const expectEqual = std.testing.expectEqual; const mem = std.mem; test "continue in for loop" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const array = [_]i32{ 1, 2, 3, 4, 5 }; var sum: i32 = 0; @@ -67,10 +67,10 @@ test "ignore lval with underscore (for loop)" { } test "basic for loop" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const expected_result = [_]u8{ 9, 8, 7, 6, 0, 1, 2, 3 } ** 3; @@ -111,10 +111,10 @@ test "basic for loop" { } test "for with null and T peer types and inferred result location type" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest(slice: []const u8) !void { @@ -133,9 +133,9 @@ test "for with null and T peer types and inferred result location type" { } test "2 break statements and an else" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn entry(t: bool, f: bool) !void { @@ -154,10 +154,10 @@ test "2 break statements and an else" { } test "for loop with pointer elem var" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const source = "abcdefg"; var target: [source.len]u8 = undefined; @@ -182,9 +182,9 @@ fn mangleString(s: []u8) void { } test "for copies its payload" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -201,10 +201,10 @@ test "for copies its payload" { } test "for on slice with allowzero ptr" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest(slice: []const u8) !void { @@ -218,9 +218,9 @@ test "for on slice with allowzero ptr" { } test "else continue outer for" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var i: usize = 6; var buf: [5]u8 = undefined; @@ -233,8 +233,8 @@ test "else continue outer for" { } test "for loop with else branch" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var x = [_]u32{ 1, 2 }; @@ -255,9 +255,9 @@ test "for loop with else branch" { } test "count over fixed range" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var sum: usize = 0; for (0..6) |i| { @@ -268,9 +268,9 @@ test "count over fixed range" { } test "two counters" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var sum: usize = 0; for (0..10, 10..20) |i, j| { @@ -282,9 +282,9 @@ test "two counters" { } test "1-based counter and ptr to array" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var ok: usize = 0; @@ -315,10 +315,10 @@ test "1-based counter and ptr to array" { } test "slice and two counters, one is offset and one is runtime" { - if (builtin.zig_backend == .stage2_sparc64) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const slice: []const u8 = "blah"; var start: usize = 0; @@ -344,10 +344,10 @@ test "slice and two counters, one is offset and one is runtime" { } test "two slices, one captured by-ref" { - if (builtin.zig_backend == .stage2_sparc64) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buf: [10]u8 = undefined; const slice1: []const u8 = "blah"; @@ -364,10 +364,10 @@ test "two slices, one captured by-ref" { } test "raw pointer and slice" { - if (builtin.zig_backend == .stage2_sparc64) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buf: [10]u8 = undefined; const slice: []const u8 = "blah"; @@ -384,10 +384,10 @@ test "raw pointer and slice" { } test "raw pointer and counter" { - if (builtin.zig_backend == .stage2_sparc64) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buf: [10]u8 = undefined; const ptr: [*]u8 = &buf; @@ -403,10 +403,10 @@ test "raw pointer and counter" { } test "inline for with slice as the comptime-known" { - if (builtin.zig_backend == .stage2_sparc64) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const comptime_slice = "hello"; var runtime_i: usize = 3; @@ -434,10 +434,10 @@ test "inline for with slice as the comptime-known" { } test "inline for with counter as the comptime-known" { - if (builtin.zig_backend == .stage2_sparc64) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var runtime_slice = "hello"; var runtime_i: usize = 3; @@ -465,10 +465,10 @@ test "inline for with counter as the comptime-known" { } test "inline for on tuple pointer" { - if (builtin.zig_backend == .stage2_sparc64) 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_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { u32, u32, u32 }; var s: S = .{ 100, 200, 300 }; @@ -481,10 +481,10 @@ test "inline for on tuple pointer" { } test "ref counter that starts at zero" { - if (builtin.zig_backend == .stage2_sparc64) 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_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO for ([_]usize{ 0, 1, 2 }, 0..) |i, j| { try expectEqual(i, j); @@ -497,10 +497,10 @@ test "ref counter that starts at zero" { } test "inferred alloc ptr of for loop" { - if (builtin.zig_backend == .stage2_sparc64) 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_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO { var cond = false; diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig index 095461522331..4f3272cd7838 100644 --- a/test/behavior/generics.zig +++ b/test/behavior/generics.zig @@ -17,8 +17,8 @@ fn checkSize(comptime T: type) usize { } test "simple generic fn" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(max(i32, 3, -1) == 3); try expect(max(u8, 1, 100) == 100); @@ -52,10 +52,10 @@ fn sameButWithFloats(a: f64, b: f64) f64 { } test "fn with comptime args" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(gimmeTheBigOne(1234, 5678) == 5678); try expect(shouldCallSameInstance(34, 12) == 34); @@ -63,10 +63,10 @@ test "fn with comptime args" { } test "anytype params" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(max_i32(12, 34) == 34); try expect(max_f64(1.2, 3.4) == 3.4); @@ -89,9 +89,9 @@ fn max_f64(a: f64, b: f64) f64 { } test "type constructed by comptime function call" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var l: SimpleList(10) = undefined; l.array[0] = 10; @@ -112,10 +112,10 @@ fn SimpleList(comptime L: usize) type { } test "function with return type type" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var list: List(i32) = undefined; var list2: List(i32) = undefined; @@ -147,7 +147,7 @@ fn GenericDataThing(comptime count: isize) type { } test "use generic param in generic param" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(aGenericFn(i32, 3, 4) == 7); } @@ -156,10 +156,10 @@ fn aGenericFn(comptime T: type, comptime a: T, b: T) T { } test "generic fn with implicit cast" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(getFirstByte(u8, &[_]u8{13}) == 13); try expect(getFirstByte(u16, &[_]u16{ @@ -175,10 +175,10 @@ fn getFirstByte(comptime T: type, mem: []const T) u8 { } test "generic fn keeps non-generic parameter types" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const A = 128; @@ -212,8 +212,8 @@ fn foo2(arg: anytype) bool { } test "generic struct" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a1 = GenNode(i32){ .value = 13, @@ -251,10 +251,10 @@ test "function parameter is generic" { } test "generic function instantiation turns into comptime call" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -287,7 +287,7 @@ test "generic function instantiation turns into comptime call" { } test "generic function with void and comptime parameter" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { x: i32 }; const namespace = struct { @@ -302,9 +302,9 @@ test "generic function with void and comptime parameter" { } test "anonymous struct return type referencing comptime parameter" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { pub fn extraData(comptime T: type, index: usize) struct { data: T, end: usize } { @@ -320,10 +320,10 @@ test "anonymous struct return type referencing comptime parameter" { } test "generic function instantiation non-duplicates" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (builtin.os.tag == .wasi) return error.SkipZigTest; const S = struct { @@ -340,8 +340,8 @@ test "generic function instantiation non-duplicates" { } test "generic instantiation of tagged union with only one field" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO if (builtin.os.tag == .wasi) return error.SkipZigTest; const S = struct { @@ -359,7 +359,7 @@ test "generic instantiation of tagged union with only one field" { } test "nested generic function" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo(comptime T: type, callback: *const fn (user_data: T) anyerror!void, data: T) anyerror!void { @@ -376,7 +376,7 @@ test "nested generic function" { } test "extern function used as generic parameter" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { extern fn usedAsGenericParameterFoo() void; @@ -390,7 +390,7 @@ test "extern function used as generic parameter" { } test "generic struct as parameter type" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest(comptime Int: type, thing: struct { int: Int }) !void { @@ -405,7 +405,7 @@ test "generic struct as parameter type" { } test "slice as parameter type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn internComptimeString(comptime str: []const u8) *const []const u8 { @@ -421,7 +421,7 @@ test "slice as parameter type" { } test "null sentinel pointer passed as generic argument" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest(a: anytype) !void { @@ -432,8 +432,8 @@ test "null sentinel pointer passed as generic argument" { } test "generic function passed as comptime argument" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doMath(comptime f: fn (type, i32, i32) error{Overflow}!i32, a: i32, b: i32) !void { @@ -445,8 +445,8 @@ test "generic function passed as comptime argument" { } test "return type of generic function is function pointer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn b(comptime T: type) ?*const fn () error{}!T { @@ -458,8 +458,8 @@ test "return type of generic function is function pointer" { } test "coerced function body has inequal value with its uncoerced body" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const A = B(i32, c); diff --git a/test/behavior/if.zig b/test/behavior/if.zig index a38f68cf91c9..c515162ba56b 100644 --- a/test/behavior/if.zig +++ b/test/behavior/if.zig @@ -44,8 +44,8 @@ var global_with_val: anyerror!u32 = 0; var global_with_err: anyerror!u32 = error.SomeError; test "unwrap mutable global var" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (global_with_val) |v| { try expect(v == 0); @@ -79,8 +79,8 @@ test "const result loc, runtime if cond, else unreachable" { } test "if copies its payload" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -113,10 +113,10 @@ test "if prongs cast to expected type instead of peer type resolution" { } test "if peer expressions inferred optional type" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var self: []const u8 = "abcdef"; var index: usize = 0; @@ -131,10 +131,10 @@ test "if peer expressions inferred optional type" { } test "if-else expression with runtime condition result location is inferred optional" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const A = struct { b: u64, c: u64 }; var d: bool = true; diff --git a/test/behavior/incomplete_struct_param_tld.zig b/test/behavior/incomplete_struct_param_tld.zig index 4edf974daba2..75a2d79b36f9 100644 --- a/test/behavior/incomplete_struct_param_tld.zig +++ b/test/behavior/incomplete_struct_param_tld.zig @@ -22,7 +22,7 @@ fn foo(a: A) i32 { } test "incomplete struct param top level declaration" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const a = A{ .b = B{ diff --git a/test/behavior/inline_switch.zig b/test/behavior/inline_switch.zig index fc2eae31befc..b33d7c7e32a8 100644 --- a/test/behavior/inline_switch.zig +++ b/test/behavior/inline_switch.zig @@ -3,8 +3,8 @@ const expect = std.testing.expect; const builtin = @import("builtin"); test "inline scalar prongs" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var x: usize = 0; switch (x) { @@ -18,8 +18,8 @@ test "inline scalar prongs" { } test "inline prong ranges" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var x: usize = 0; switch (x) { @@ -32,8 +32,8 @@ test "inline prong ranges" { const E = enum { a, b, c, d }; test "inline switch enums" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var x: E = .a; switch (x) { @@ -44,10 +44,10 @@ test "inline switch enums" { const U = union(E) { a: void, b: u2, c: u3, d: u4 }; test "inline switch unions" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: U = .a; switch (x) { @@ -71,9 +71,9 @@ test "inline switch unions" { } test "inline else bool" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a = true; switch (a) { @@ -83,9 +83,9 @@ test "inline else bool" { } test "inline else error" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Err = error{ a, b, c }; var a = Err.a; @@ -96,8 +96,8 @@ test "inline else error" { } test "inline else enum" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const E2 = enum(u8) { a = 2, b = 3, c = 4, d = 5 }; var a: E2 = .a; @@ -108,8 +108,8 @@ test "inline else enum" { } test "inline else int with gaps" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var a: u8 = 0; switch (a) { @@ -125,8 +125,8 @@ test "inline else int with gaps" { } test "inline else int all values" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var a: u2 = 0; switch (a) { @@ -141,7 +141,7 @@ test "inline else int all values" { } test "inline switch capture is set when switch operand is comptime known" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U2 = union(enum) { a: u32, diff --git a/test/behavior/int128.zig b/test/behavior/int128.zig index 42f0b00922ad..2043c5885610 100644 --- a/test/behavior/int128.zig +++ b/test/behavior/int128.zig @@ -5,10 +5,10 @@ const minInt = std.math.minInt; const builtin = @import("builtin"); test "uint128" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buff: u128 = maxInt(u128); try expect(buff == maxInt(u128)); @@ -24,10 +24,10 @@ test "uint128" { } test "undefined 128 bit int" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; @setRuntimeSafety(true); @@ -42,10 +42,10 @@ test "undefined 128 bit int" { } test "int128" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buff: i128 = -1; try expect(buff < 0 and (buff + 1) == 0); @@ -64,12 +64,12 @@ test "int128" { } test "truncate int128" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var buff: u128 = maxInt(u128); @@ -87,10 +87,10 @@ test "truncate int128" { } test "shift int128" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const types = .{ u128, i128 }; inline for (types) |t| { diff --git a/test/behavior/int_comparison_elision.zig b/test/behavior/int_comparison_elision.zig index 32c670fff425..5d86cc1542f9 100644 --- a/test/behavior/int_comparison_elision.zig +++ b/test/behavior/int_comparison_elision.zig @@ -4,7 +4,7 @@ const maxInt = std.math.maxInt; const builtin = @import("builtin"); test "int comparison elision" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; testIntEdges(u0); testIntEdges(i0); @@ -14,9 +14,9 @@ test "int comparison elision" { testIntEdges(i4); // TODO: support int types > 128 bits wide in other backends - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO // TODO: panic: integer overflow with int types > 65528 bits wide // TODO: LLVM generates too many parameters for wasmtime when splitting up int > 64000 bits wide diff --git a/test/behavior/int_div.zig b/test/behavior/int_div.zig index 98e4b361c754..ac28d4462ca3 100644 --- a/test/behavior/int_div.zig +++ b/test/behavior/int_div.zig @@ -3,10 +3,10 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test "integer division" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testDivision(); try comptime testDivision(); @@ -93,10 +93,10 @@ fn rem(comptime T: type, a: T, b: T) T { } test "large integer division" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; { var numerator: u256 = 99999999999999999997315645440; diff --git a/test/behavior/ir_block_deps.zig b/test/behavior/ir_block_deps.zig index 136f23409bfd..5fb8d5317fbe 100644 --- a/test/behavior/ir_block_deps.zig +++ b/test/behavior/ir_block_deps.zig @@ -18,10 +18,10 @@ fn getErrInt() anyerror!i32 { } test "ir block deps" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect((foo(1) catch unreachable) == 0); try expect((foo(2) catch unreachable) == 0); diff --git a/test/behavior/lower_strlit_to_vector.zig b/test/behavior/lower_strlit_to_vector.zig index 41faad14c076..4b7c76500bca 100644 --- a/test/behavior/lower_strlit_to_vector.zig +++ b/test/behavior/lower_strlit_to_vector.zig @@ -2,11 +2,11 @@ const std = @import("std"); const builtin = @import("builtin"); test "strlit to vector" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const strlit = "0123456789abcdef0123456789ABCDEF"; const vec_from_strlit: @Vector(32, u8) = strlit.*; diff --git a/test/behavior/math.zig b/test/behavior/math.zig index 4001b1002dd8..38f65f389199 100644 --- a/test/behavior/math.zig +++ b/test/behavior/math.zig @@ -9,9 +9,9 @@ const mem = std.mem; const math = std.math; test "assignment operators" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var i: u32 = 0; i += 5; @@ -61,10 +61,10 @@ fn assertFalse(b: bool) !void { } test "@clz" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testClz(); try comptime testClz(); @@ -78,12 +78,12 @@ fn testClz() !void { } test "@clz big ints" { - if (builtin.zig_backend == .stage2_x86_64 and + if (builtin.zig_backend == .zsf_x86_64 and !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .lzcnt)) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testClzBigInts(); try comptime testClzBigInts(); @@ -99,12 +99,12 @@ fn testOneClz(comptime T: type, x: T) u32 { } test "@clz vectors" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testClzVectors(); try comptime testClzVectors(); @@ -145,10 +145,10 @@ fn expectVectorsEqual(a: anytype, b: anytype) !void { } test "@ctz" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testCtz(); try comptime testCtz(); @@ -166,14 +166,14 @@ fn testOneCtz(comptime T: type, x: T) u32 { } test "@ctz vectors" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .aarch64) { // This regressed with LLVM 14: // https://github.com/ziglang/zig/issues/12013 return error.SkipZigTest; @@ -211,9 +211,9 @@ test "const number literal" { const ten = 10; test "float equality" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const x: f64 = 0.012; const y: f64 = x + 1.0; @@ -387,11 +387,11 @@ fn testBinaryNot(x: u16) !void { } test "binary not 128-bit" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(comptime x: { break :x ~@as(u128, 0x55555555_55555555_55555555_55555555) == 0xaaaaaaaa_aaaaaaaa_aaaaaaaa_aaaaaaaa; @@ -409,13 +409,13 @@ fn testBinaryNot128(comptime Type: type, x: Type) !void { } test "division" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64 and !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testDivision(); try comptime testDivision(); @@ -491,11 +491,11 @@ fn testDivision() !void { } test "division half-precision floats" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testDivisionFP16(); try comptime testDivisionFP16(); @@ -574,9 +574,9 @@ fn testUnsignedNegationWrappingEval(x: u16) !void { } test "negation wrapping" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqual(@as(u1, 1), negateWrap(u1, 1)); } @@ -588,8 +588,8 @@ fn negateWrap(comptime T: type, x: T) T { } test "unsigned 64-bit division" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try test_u64_div(); try comptime test_u64_div(); @@ -617,7 +617,7 @@ test "bit shift a u1" { } test "truncating shift right" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testShrTrunc(maxInt(u16)); try comptime testShrTrunc(maxInt(u16)); @@ -628,12 +628,12 @@ fn testShrTrunc(x: u16) !void { } test "f128" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try test_f128(); try comptime test_f128(); @@ -658,13 +658,13 @@ fn should_not_be_zero(x: f128) !void { } test "128-bit multiplication" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; { var a: i128 = 3; @@ -687,9 +687,9 @@ test "128-bit multiplication" { } test "@addWithOverflow" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO { var a: u8 = 250; @@ -733,9 +733,9 @@ test "@addWithOverflow" { } test "small int addition" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u2 = 0; try expect(x == 0); @@ -755,9 +755,9 @@ test "small int addition" { } test "basic @mulWithOverflow" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var a: u8 = 86; @@ -785,9 +785,9 @@ test "basic @mulWithOverflow" { } test "extensive @mulWithOverflow" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var a: u5 = 3; @@ -948,11 +948,11 @@ test "extensive @mulWithOverflow" { test "@mulWithOverflow bitsize > 32" { // aarch64 fails on a release build of the compiler. - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var a: u62 = 3; @@ -1008,10 +1008,10 @@ test "@mulWithOverflow bitsize > 32" { } test "@subWithOverflow" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var a: u8 = 1; @@ -1056,9 +1056,9 @@ test "@subWithOverflow" { } test "@shlWithOverflow" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var a: u4 = 2; @@ -1137,7 +1137,7 @@ test "overflow arithmetic with u0 values" { } test "allow signed integer division/remainder when values are comptime-known and positive or exact" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(5 / 3 == 1); try expect(-5 / -3 == 1); @@ -1153,11 +1153,11 @@ test "allow signed integer division/remainder when values are comptime-known and } test "quad hex float literal parsing accurate" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a: f128 = 0x1.1111222233334444555566667777p+0; @@ -1258,7 +1258,7 @@ fn testShlTrunc(x: u16) !void { } test "exact shift left" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testShlExact(0b00110101); try comptime testShlExact(0b00110101); @@ -1269,7 +1269,7 @@ fn testShlExact(x: u8) !void { } test "exact shift right" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testShrExact(0b10110100); try comptime testShrExact(0b10110100); @@ -1306,15 +1306,15 @@ test "comptime float rem int" { } test "remainder division" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; - - if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) { + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + + if (builtin.zig_backend == .zsf_llvm and builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/12602 return error.SkipZigTest; } @@ -1344,12 +1344,12 @@ fn remdivOne(comptime T: type, a: T, b: T, c: T) !void { } test "float remainder division using @rem" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO try comptime frem(f16); try comptime frem(f32); @@ -1387,12 +1387,12 @@ fn fremOne(comptime T: type, a: T, b: T, c: T, epsilon: T) !void { } test "float modulo division using @mod" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime fmod(f16); try comptime fmod(f32); @@ -1430,12 +1430,12 @@ fn fmodOne(comptime T: type, a: T, b: T, c: T, epsilon: T) !void { } test "@round" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testRound(f64, 12.0); try comptime testRound(f64, 12.0); @@ -1451,26 +1451,26 @@ test "@round" { } test "@round f80" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; try testRound(f80, 12.0); try comptime testRound(f80, 12.0); } test "@round f128" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; try testRound(f128, 12.0); try comptime testRound(f128, 12.0); @@ -1483,12 +1483,12 @@ fn testRound(comptime T: type, x: T) !void { } test "vector integer addition" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1505,12 +1505,12 @@ test "vector integer addition" { } test "NaN comparison" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testNanEqNan(f16); try testNanEqNan(f32); @@ -1523,12 +1523,12 @@ test "NaN comparison" { } test "NaN comparison f80" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testNanEqNan(f80); try comptime testNanEqNan(f80); @@ -1546,12 +1546,12 @@ fn testNanEqNan(comptime F: type) !void { } test "vector comparison" { - if (builtin.zig_backend == .stage2_wasm) 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_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1577,11 +1577,11 @@ test "compare undefined literal with comptime_int" { } test "signed zeros are represented properly" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1612,11 +1612,11 @@ test "comptime sin and ln" { } test "absFloat" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testAbsFloat(); try comptime testAbsFloat(); diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig index 609ce6e225f8..6b24f305626f 100644 --- a/test/behavior/maximum_minimum.zig +++ b/test/behavior/maximum_minimum.zig @@ -6,10 +6,10 @@ const expect = std.testing.expect; const expectEqual = std.testing.expectEqual; test "@max" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -24,13 +24,13 @@ test "@max" { } test "@max on vectors" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64 and !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -55,10 +55,10 @@ test "@max on vectors" { } test "@min" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -73,13 +73,13 @@ test "@min" { } test "@min for vectors" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64 and !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -104,13 +104,13 @@ test "@min for vectors" { } test "@min/max for floats" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; const S = struct { fn doTheTest(comptime T: type) !void { @@ -138,7 +138,7 @@ test "@min/@max on lazy values" { } test "@min/@max more than two arguments" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const x: u32 = 30; const y: u32 = 10; @@ -148,11 +148,11 @@ test "@min/@max more than two arguments" { } test "@min/@max more than two vector arguments" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const x: @Vector(2, u32) = .{ 3, 2 }; const y: @Vector(2, u32) = .{ 4, 1 }; @@ -162,10 +162,10 @@ test "@min/@max more than two vector arguments" { } test "@min/@max notices bounds" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u16 = 20; const y = 30; @@ -179,12 +179,12 @@ test "@min/@max notices bounds" { } test "@min/@max notices vector bounds" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: @Vector(2, u16) = .{ 140, 40 }; const y: @Vector(2, u64) = .{ 5, 100 }; @@ -198,11 +198,11 @@ test "@min/@max notices vector bounds" { } test "@min/@max on comptime_int" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const min = @min(1, 2, -2, -1); const max = @max(1, 2, -2, -1); @@ -214,10 +214,10 @@ test "@min/@max on comptime_int" { } test "@min/@max notices bounds from types" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u16 = 123; var y: u32 = 456; @@ -234,12 +234,12 @@ test "@min/@max notices bounds from types" { } test "@min/@max notices bounds from vector types" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: @Vector(2, u16) = .{ 30, 67 }; var y: @Vector(2, u32) = .{ 20, 500 }; @@ -256,10 +256,10 @@ test "@min/@max notices bounds from vector types" { } test "@min/@max notices bounds from types when comptime-known value is undef" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u32 = 1_000_000; const y: u16 = undefined; @@ -275,12 +275,12 @@ test "@min/@max notices bounds from types when comptime-known value is undef" { } test "@min/@max notices bounds from vector types when element of comptime-known vector is undef" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: @Vector(2, u32) = .{ 1_000_000, 12345 }; const y: @Vector(2, u16) = .{ 10, undefined }; @@ -298,7 +298,7 @@ test "@min/@max notices bounds from vector types when element of comptime-known } test "@min/@max of signed and unsigned runtime integers" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: i32 = -1; var y: u31 = 1; diff --git a/test/behavior/member_func.zig b/test/behavior/member_func.zig index bb1e1e1769b8..1f5dcb8ba43f 100644 --- a/test/behavior/member_func.zig +++ b/test/behavior/member_func.zig @@ -27,10 +27,10 @@ const HasFuncs = struct { }; test "standard field calls" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(HasFuncs.one(0) == 1); try expect(HasFuncs.two(0) == 2); @@ -71,10 +71,10 @@ test "standard field calls" { } test "@field field calls" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(@field(HasFuncs, "one")(0) == 1); try expect(@field(HasFuncs, "two")(0) == 2); diff --git a/test/behavior/memcpy.zig b/test/behavior/memcpy.zig index f1776dfe570c..01d96a435fbb 100644 --- a/test/behavior/memcpy.zig +++ b/test/behavior/memcpy.zig @@ -3,10 +3,10 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test "memcpy and memset intrinsics" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testMemcpyMemset(); try comptime testMemcpyMemset(); @@ -25,10 +25,10 @@ fn testMemcpyMemset() !void { } test "@memcpy with both operands single-ptr-to-array, one is null-terminated" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testMemcpyBothSinglePtrArrayOneIsNullTerminated(); try comptime testMemcpyBothSinglePtrArrayOneIsNullTerminated(); @@ -46,10 +46,10 @@ fn testMemcpyBothSinglePtrArrayOneIsNullTerminated() !void { } test "@memcpy dest many pointer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testMemcpyDestManyPtr(); try comptime testMemcpyDestManyPtr(); @@ -68,7 +68,7 @@ fn testMemcpyDestManyPtr() !void { } comptime { - if (builtin.zig_backend != .stage2_spirv64) { + if (builtin.zig_backend != .zsf_spirv64) { const S = struct { buffer: [8]u8 = undefined, fn set(self: *@This(), items: []const u8) void { diff --git a/test/behavior/memset.zig b/test/behavior/memset.zig index 32d9cf1eb842..a5ba89b7823f 100644 --- a/test/behavior/memset.zig +++ b/test/behavior/memset.zig @@ -3,10 +3,10 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test "@memset on array pointers" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testMemsetArray(); try comptime testMemsetArray(); @@ -32,10 +32,10 @@ fn testMemsetArray() !void { } test "@memset on slices" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testMemsetSlice(); try comptime testMemsetSlice(); @@ -65,10 +65,10 @@ fn testMemsetSlice() !void { } test "memset with bool element" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buf: [5]bool = undefined; @memset(&buf, true); @@ -77,10 +77,10 @@ test "memset with bool element" { } test "memset with 1-byte struct element" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { x: bool }; var buf: [5]S = undefined; @@ -90,10 +90,10 @@ test "memset with 1-byte struct element" { } test "memset with 1-byte array element" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const A = [1]bool; var buf: [5]A = undefined; @@ -103,10 +103,10 @@ test "memset with 1-byte array element" { } test "memset with large array element, runtime known" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const A = [128]u64; var buf: [5]A = undefined; @@ -120,10 +120,10 @@ test "memset with large array element, runtime known" { } test "memset with large array element, comptime known" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const A = [128]u64; var buf: [5]A = undefined; diff --git a/test/behavior/merge_error_sets.zig b/test/behavior/merge_error_sets.zig index 62aa77fb18c8..f822c3ab4545 100644 --- a/test/behavior/merge_error_sets.zig +++ b/test/behavior/merge_error_sets.zig @@ -12,8 +12,8 @@ fn foo() C!void { } test "merge error sets" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (foo()) { @panic("unexpected"); diff --git a/test/behavior/muladd.zig b/test/behavior/muladd.zig index e4738836213b..6bc4f9dfd081 100644 --- a/test/behavior/muladd.zig +++ b/test/behavior/muladd.zig @@ -2,15 +2,15 @@ const std = @import("std"); const builtin = @import("builtin"); const expect = std.testing.expect; -const no_x86_64_hardware_fma_support = builtin.zig_backend == .stage2_x86_64 and +const no_x86_64_hardware_fma_support = builtin.zig_backend == .zsf_x86_64 and !std.Target.x86.featureSetHas(builtin.cpu.features, .fma); test "@mulAdd" { if (no_x86_64_hardware_fma_support) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testMulAdd(); try testMulAdd(); @@ -32,11 +32,11 @@ fn testMulAdd() !void { } test "@mulAdd f16" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testMulAdd16(); try testMulAdd16(); @@ -50,13 +50,13 @@ fn testMulAdd16() !void { } test "@mulAdd f80" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; try comptime testMulAdd80(); try testMulAdd80(); @@ -70,13 +70,13 @@ fn testMulAdd80() !void { } test "@mulAdd f128" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; try comptime testMulAdd128(); try testMulAdd128(); @@ -102,12 +102,12 @@ fn vector16() !void { } test "vector f16" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime vector16(); try vector16(); @@ -126,12 +126,12 @@ fn vector32() !void { } test "vector f32" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO if (no_x86_64_hardware_fma_support) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime vector32(); try vector32(); @@ -150,12 +150,12 @@ fn vector64() !void { } test "vector f64" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO if (no_x86_64_hardware_fma_support) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime vector64(); try vector64(); @@ -173,13 +173,13 @@ fn vector80() !void { } test "vector f80" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; try comptime vector80(); try vector80(); @@ -198,13 +198,13 @@ fn vector128() !void { } test "vector f128" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; try comptime vector128(); try vector128(); diff --git a/test/behavior/null.zig b/test/behavior/null.zig index e9fc66f4b8b6..9d89fc855103 100644 --- a/test/behavior/null.zig +++ b/test/behavior/null.zig @@ -29,10 +29,10 @@ test "optional type" { } test "test maybe object and get a pointer to the inner value" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var maybe_bool: ?bool = true; @@ -50,10 +50,10 @@ test "rhs maybe unwrap return" { } test "maybe return" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try maybeReturnImpl(); try comptime maybeReturnImpl(); @@ -71,8 +71,8 @@ fn foo(x: ?i32) ?bool { } test "test null runtime" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testTestNullRuntime(null); } @@ -82,9 +82,9 @@ fn testTestNullRuntime(x: ?i32) !void { } test "optional void" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try optionalVoidImpl(); try comptime optionalVoidImpl(); @@ -106,9 +106,9 @@ fn bar(x: ?void) ?void { const Empty = struct {}; test "optional struct{}" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; _ = try optionalEmptyStructImpl(); _ = try comptime optionalEmptyStructImpl(); @@ -133,8 +133,8 @@ test "null with default unwrap" { } test "optional pointer to 0 bit type null value at runtime" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const EmptyStruct = struct {}; var x: ?*EmptyStruct = null; @@ -142,10 +142,10 @@ test "optional pointer to 0 bit type null value at runtime" { } test "if var maybe pointer" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(shouldBeAPlus1(Particle{ .a = 14, @@ -186,10 +186,10 @@ const SillyStruct = struct { const here_is_a_null_literal = SillyStruct{ .context = null }; test "unwrap optional which is field of global var" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; struct_with_optional.field = null; if (struct_with_optional.field) |payload| { diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig index 496da99e0031..3f0fb7ae7a4b 100644 --- a/test/behavior/optional.zig +++ b/test/behavior/optional.zig @@ -6,8 +6,8 @@ const expectEqual = testing.expectEqual; const expectEqualStrings = std.testing.expectEqualStrings; test "passing an optional integer as a parameter" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn entry() bool { @@ -26,8 +26,8 @@ test "passing an optional integer as a parameter" { pub const EmptyStruct = struct {}; test "optional pointer to size zero struct" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var e = EmptyStruct{}; var o: ?*EmptyStruct = &e; @@ -35,7 +35,7 @@ test "optional pointer to size zero struct" { } test "equality compare optional pointers" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testNullPtrsEql(); try comptime testNullPtrsEql(); @@ -58,10 +58,10 @@ fn testNullPtrsEql() !void { } test "optional with void type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Foo = struct { x: ?void, @@ -71,10 +71,10 @@ test "optional with void type" { } test "address of unwrap optional" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Foo = struct { @@ -93,10 +93,10 @@ test "address of unwrap optional" { } test "nested optional field in struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S2 = struct { y: u8, @@ -111,10 +111,10 @@ test "nested optional field in struct" { } test "equality compare optional with non-optional" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try test_cmp_optional_non_optional(); try comptime test_cmp_optional_non_optional(); @@ -150,9 +150,9 @@ fn test_cmp_optional_non_optional() !void { } test "unwrap function call with optional pointer return value" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn entry() !void { @@ -172,9 +172,9 @@ test "unwrap function call with optional pointer return value" { } test "nested orelse" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn entry() !void { @@ -199,9 +199,9 @@ test "nested orelse" { } test "self-referential struct through a slice of optional" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Node = struct { @@ -234,10 +234,10 @@ test "assigning to an unwrapped optional field in an inline loop" { } test "coerce an anon struct literal to optional struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Struct = struct { @@ -254,10 +254,10 @@ test "coerce an anon struct literal to optional struct" { } test "0-bit child type coerced to optional return ptr result location" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -281,8 +281,8 @@ test "0-bit child type coerced to optional return ptr result location" { } test "0-bit child type coerced to optional" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -307,10 +307,10 @@ test "0-bit child type coerced to optional" { } test "array of optional unaligned types" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Enum = enum { one, two, three }; @@ -344,10 +344,10 @@ test "array of optional unaligned types" { } test "optional pointer to zero bit optional payload" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const B = struct { fn foo(_: *@This()) void {} @@ -363,10 +363,10 @@ test "optional pointer to zero bit optional payload" { } test "optional pointer to zero bit error union payload" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const B = struct { fn foo(_: *@This()) void {} @@ -399,8 +399,8 @@ const NoReturn = struct { }; test "optional of noreturn used with if" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; NoReturn.a = 64; if (NoReturn.loop()) |_| { @@ -411,8 +411,8 @@ test "optional of noreturn used with if" { } test "optional of noreturn used with orelse" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; NoReturn.a = 64; const val = NoReturn.testOrelse(); @@ -428,10 +428,10 @@ test "orelse on C pointer" { } test "alignment of wrapping an optional payload" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const I = extern struct { x: i128 }; @@ -445,10 +445,10 @@ test "alignment of wrapping an optional payload" { } test "Optional slice size is optimized" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(@sizeOf(?[]u8) == @sizeOf([]u8)); var a: ?[]const u8 = null; @@ -458,9 +458,9 @@ test "Optional slice size is optimized" { } test "peer type resolution in nested if expressions" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Thing = struct { n: i32 }; var a = false; @@ -484,9 +484,9 @@ test "peer type resolution in nested if expressions" { } test "cast slice to const slice nested in error union and optional" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn inner() !?[]u8 { diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig index e1520e0c40ca..85f1d0f233a3 100644 --- a/test/behavior/packed-struct.zig +++ b/test/behavior/packed-struct.zig @@ -6,7 +6,7 @@ const expectEqual = std.testing.expectEqual; const native_endian = builtin.cpu.arch.endian(); test "flags in packed structs" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const Flags1 = packed struct { // first 8 bits @@ -92,7 +92,7 @@ test "flags in packed structs" { } test "consistent size of packed structs" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const TxData1 = packed struct { data: u8, _23: u23, full: bool = false }; const TxData2 = packed struct { data: u9, _22: u22, full: bool = false }; @@ -120,10 +120,10 @@ test "consistent size of packed structs" { } test "correct sizeOf and offsets in packed structs" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const PStruct = packed struct { bool_a: bool, @@ -188,10 +188,10 @@ test "correct sizeOf and offsets in packed structs" { } test "nested packed structs" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S1 = packed struct { a: u8, b: u8, c: u8 }; @@ -234,10 +234,10 @@ test "nested packed structs" { } test "regular in irregular packed struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Irregular = packed struct { bar: Regular = Regular{}, @@ -254,10 +254,10 @@ test "regular in irregular packed struct" { } test "byte-aligned field pointer offsets" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const A = packed struct { @@ -355,10 +355,10 @@ test "byte-aligned field pointer offsets" { } test "load pointer from packed struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const A = struct { index: u16, @@ -376,10 +376,10 @@ test "load pointer from packed struct" { } test "@intFromPtr on a packed struct field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const P = packed struct { @@ -397,10 +397,10 @@ test "@intFromPtr on a packed struct field" { } test "optional pointer in packed struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = packed struct { ptr: ?*const u8 }; var n: u8 = 0; @@ -409,13 +409,13 @@ test "optional pointer in packed struct" { } test "nested packed struct field access test" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // const Vec2 = packed struct { x: f32, @@ -529,8 +529,8 @@ test "nested packed struct field access test" { } test "nested packed struct at non-zero offset" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Pair = packed struct(u24) { a: u16 = 0, @@ -557,13 +557,13 @@ test "nested packed struct at non-zero offset" { } test "nested packed struct at non-zero offset 2" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; const S = struct { const Pair = packed struct(u40) { @@ -623,10 +623,10 @@ test "nested packed struct at non-zero offset 2" { } test "runtime init of unnamed packed struct type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var z: u8 = 123; try (packed struct { @@ -638,10 +638,10 @@ test "runtime init of unnamed packed struct type" { } test "packed struct passed to callconv(.C) function" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Packed = packed struct { @@ -664,10 +664,10 @@ test "packed struct passed to callconv(.C) function" { } test "overaligned pointer to packed struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = packed struct { a: u32, b: u32 }; var foo: S align(4) = .{ .a = 123, .b = 456 }; @@ -686,10 +686,10 @@ test "overaligned pointer to packed struct" { } test "packed struct initialized in bitcast" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = packed struct { val: u8 }; var val: u8 = 123; @@ -698,11 +698,11 @@ test "packed struct initialized in bitcast" { } test "pointer to container level packed struct field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = packed struct(u32) { test_bit: bool, @@ -724,10 +724,10 @@ test "pointer to container level packed struct field" { } test "store undefined to packed result location" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; var x: u4 = 0; var s = packed struct { x: u4, y: u4 }{ .x = x, .y = if (x > 0) x else undefined }; diff --git a/test/behavior/packed-union.zig b/test/behavior/packed-union.zig index ceb22e1ba9db..62f938c7c276 100644 --- a/test/behavior/packed-union.zig +++ b/test/behavior/packed-union.zig @@ -3,10 +3,10 @@ const builtin = @import("builtin"); const expectEqual = std.testing.expectEqual; test "flags in packed union" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const FlagBits = packed struct(u8) { enable_1: bool = false, diff --git a/test/behavior/packed_struct_explicit_backing_int.zig b/test/behavior/packed_struct_explicit_backing_int.zig index 9e476572abd6..9a1a1b5d529a 100644 --- a/test/behavior/packed_struct_explicit_backing_int.zig +++ b/test/behavior/packed_struct_explicit_backing_int.zig @@ -5,11 +5,11 @@ const expectEqual = std.testing.expectEqual; const native_endian = builtin.cpu.arch.endian(); test "packed struct explicit backing integer" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S1 = packed struct { a: u8, b: u8, c: u8 }; diff --git a/test/behavior/pointers.zig b/test/behavior/pointers.zig index d007e7b48082..69b984111994 100644 --- a/test/behavior/pointers.zig +++ b/test/behavior/pointers.zig @@ -17,8 +17,8 @@ fn testDerefPtr() !void { } test "pointer arithmetic" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var ptr: [*]const u8 = "abcd"; @@ -50,7 +50,7 @@ fn PtrOf(comptime T: type) type { } test "implicit cast single item pointer to C pointer and back" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var y: u8 = 11; var x: [*c]u8 = &y; @@ -66,7 +66,7 @@ test "initialize const optional C pointer to null" { } test "assigning integer to C pointer" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var x: i32 = 0; var y: i32 = 1; @@ -82,7 +82,7 @@ test "assigning integer to C pointer" { } test "C pointer comparison and arithmetic" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -125,7 +125,7 @@ fn testDerefPtrOneVal() !void { } test "peer type resolution with C pointers" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var ptr_one: *u8 = undefined; var ptr_many: [*]u8 = undefined; var ptr_c: [*c]u8 = undefined; @@ -141,17 +141,17 @@ test "peer type resolution with C pointers" { } test "peer type resolution with C pointer and const pointer" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var ptr_c: [*c]u8 = undefined; const ptr_const: u8 = undefined; try expect(@TypeOf(ptr_c, &ptr_const) == [*c]const u8); } test "implicit casting between C pointer and optional non-C pointer" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var slice: []const u8 = "aoeu"; const opt_many_ptr: ?[*]const u8 = slice.ptr; @@ -163,10 +163,10 @@ test "implicit casting between C pointer and optional non-C pointer" { } test "implicit cast error unions with non-optional to optional pointer" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -191,11 +191,11 @@ test "compare equality of optional and non-optional pointer" { } test "allowzero pointer and slice" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var ptr = @as([*]allowzero i32, @ptrFromInt(0)); var opt_ptr: ?[*]allowzero i32 = ptr; @@ -211,10 +211,10 @@ test "allowzero pointer and slice" { } test "assign null directly to C pointer and test null equality" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: [*c]i32 = null; try expect(x == null); @@ -279,9 +279,9 @@ test "array initialization types" { } test "null terminated pointer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -297,8 +297,8 @@ test "null terminated pointer" { } test "allow any sentinel" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -312,9 +312,9 @@ test "allow any sentinel" { } test "pointer sentinel with enums" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Number = enum { @@ -333,10 +333,10 @@ test "pointer sentinel with enums" { } test "pointer sentinel with optional element" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -349,11 +349,11 @@ test "pointer sentinel with optional element" { } test "pointer sentinel with +inf" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -374,7 +374,7 @@ test "pointer to array at fixed address" { } test "pointer arithmetic affects the alignment" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var ptr: [*]align(8) u32 = undefined; var x: usize = 1; @@ -418,19 +418,19 @@ test "@intFromPtr on null optional at comptime" { } test "indexing array with sentinel returns correct type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var s: [:0]const u8 = "abc"; try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0]))); } test "element pointer to slice" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -451,9 +451,9 @@ test "element pointer to slice" { } test "element pointer arithmetic to slice" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -477,8 +477,8 @@ test "element pointer arithmetic to slice" { } test "array slicing to slice" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -506,10 +506,10 @@ test "pointer to constant decl preserves alignment" { } test "ptrCast comptime known slice to C pointer" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const s: [:0]const u8 = "foo"; var p = @as([*c]const u8, @ptrCast(s)); @@ -517,10 +517,10 @@ test "ptrCast comptime known slice to C pointer" { } test "intFromPtr on a generic function" { - if (builtin.zig_backend == .stage2_wasm) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn generic(i: anytype) @TypeOf(i) { @@ -544,7 +544,7 @@ test "pointer alignment and element type include call expression" { } test "pointer to array has explicit alignment" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO const S = struct { const Base = extern struct { a: u8 }; diff --git a/test/behavior/popcount.zig b/test/behavior/popcount.zig index da152d4dc525..549dacb5851d 100644 --- a/test/behavior/popcount.zig +++ b/test/behavior/popcount.zig @@ -4,21 +4,21 @@ const expect = std.testing.expect; const expectEqual = std.testing.expectEqual; test "@popCount integers" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testPopCountIntegers(); try testPopCountIntegers(); } test "@popCount 128bit integer" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { try expect(@popCount(@as(u128, 0b11111111000110001100010000100001000011000011100101010001)) == 24); @@ -68,12 +68,12 @@ fn testPopCountIntegers() !void { } test "@popCount vectors" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime testPopCountVectors(); try testPopCountVectors(); diff --git a/test/behavior/prefetch.zig b/test/behavior/prefetch.zig index cd4d8c5ababa..ed5ac798fb1c 100644 --- a/test/behavior/prefetch.zig +++ b/test/behavior/prefetch.zig @@ -2,7 +2,7 @@ const builtin = @import("builtin"); const std = @import("std"); test "@prefetch()" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: u32 = 42; diff --git a/test/behavior/ptrcast.zig b/test/behavior/ptrcast.zig index 8837c42a864c..1ff424d6f601 100644 --- a/test/behavior/ptrcast.zig +++ b/test/behavior/ptrcast.zig @@ -4,7 +4,7 @@ const expect = std.testing.expect; const native_endian = builtin.target.cpu.arch.endian(); test "reinterpret bytes as integer with nonzero offset" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testReinterpretBytesAsInteger(); try comptime testReinterpretBytesAsInteger(); @@ -20,10 +20,10 @@ fn testReinterpretBytesAsInteger() !void { } test "reinterpret an array over multiple elements, with no well-defined layout" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testReinterpretWithOffsetAndNoWellDefinedLayout(); try comptime testReinterpretWithOffsetAndNoWellDefinedLayout(); @@ -38,7 +38,7 @@ fn testReinterpretWithOffsetAndNoWellDefinedLayout() !void { } test "reinterpret bytes inside auto-layout struct as integer with nonzero offset" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testReinterpretStructWrappedBytesAsInteger(); try comptime testReinterpretStructWrappedBytesAsInteger(); @@ -55,8 +55,8 @@ fn testReinterpretStructWrappedBytesAsInteger() !void { } test "reinterpret bytes of an array into an extern struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testReinterpretBytesAsExternStruct(); try comptime testReinterpretBytesAsExternStruct(); @@ -77,7 +77,7 @@ fn testReinterpretBytesAsExternStruct() !void { } test "reinterpret bytes of an extern struct (with under-aligned fields) into another" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testReinterpretExternStructAsExternStruct(); try comptime testReinterpretExternStructAsExternStruct(); @@ -101,7 +101,7 @@ fn testReinterpretExternStructAsExternStruct() !void { } test "reinterpret bytes of an extern struct into another" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testReinterpretOverAlignedExternStructAsExternStruct(); try comptime testReinterpretOverAlignedExternStructAsExternStruct(); @@ -127,10 +127,10 @@ fn testReinterpretOverAlignedExternStructAsExternStruct() !void { } test "lower reinterpreted comptime field ptr (with under-aligned fields)" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // Test lowering a field ptr comptime var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 }; @@ -150,10 +150,10 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" { } test "lower reinterpreted comptime field ptr" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // Test lowering a field ptr comptime var bytes align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 }; @@ -173,9 +173,9 @@ test "lower reinterpreted comptime field ptr" { } test "reinterpret struct field at comptime" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const numNative = comptime Bytes.init(0x12345678); if (native_endian != .Little) { @@ -197,7 +197,7 @@ const Bytes = struct { }; test "ptrcast of const integer has the correct object size" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const is_value = ~@as(isize, @intCast(std.math.minInt(isize))); const is_bytes = @as([*]const u8, @ptrCast(&is_value))[0..@sizeOf(isize)]; @@ -230,10 +230,10 @@ test "ptrcast of const integer has the correct object size" { } test "implicit optional pointer to optional anyopaque pointer" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buf: [4]u8 = "aoeu".*; var x: ?[*]u8 = &buf; @@ -243,10 +243,10 @@ test "implicit optional pointer to optional anyopaque pointer" { } test "@ptrCast slice to slice" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo(slice: []u32) []i32 { @@ -261,9 +261,9 @@ test "@ptrCast slice to slice" { } test "comptime @ptrCast a subset of an array, then write through it" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO comptime { var buff: [16]u8 align(4) = undefined; diff --git a/test/behavior/ptrfromint.zig b/test/behavior/ptrfromint.zig index 2cf72936a12c..c59e2992f86d 100644 --- a/test/behavior/ptrfromint.zig +++ b/test/behavior/ptrfromint.zig @@ -13,9 +13,9 @@ fn addressToFunction() void { } test "mutate through ptr initialized with constant ptrFromInt value" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO forceCompilerAnalyzeBranchHardCodedPtrDereference(false); } @@ -30,20 +30,20 @@ fn forceCompilerAnalyzeBranchHardCodedPtrDereference(x: bool) void { } test "@ptrFromInt creates null pointer" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const ptr = @as(?*u32, @ptrFromInt(0)); try expectEqual(@as(?*u32, null), ptr); } test "@ptrFromInt creates allowzero zero pointer" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const ptr = @as(*allowzero u32, @ptrFromInt(0)); try expectEqual(@as(usize, 0), @intFromPtr(ptr)); diff --git a/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig b/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig index bb6d5b1359a4..42a2c5e1d8dc 100644 --- a/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig +++ b/test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig @@ -5,9 +5,9 @@ const mem = std.mem; var ok: bool = false; test "reference a variable in an if after an if in the 2nd switch prong" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try foo(true, Num.Two, false, "aoeu"); try expect(!ok); diff --git a/test/behavior/reflection.zig b/test/behavior/reflection.zig index aea84bc45ad4..5fd86fbbc75a 100644 --- a/test/behavior/reflection.zig +++ b/test/behavior/reflection.zig @@ -26,8 +26,8 @@ fn dummy(a: bool, b: i32, c: f32) i32 { } test "reflection: @field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var f = Foo{ .one = 42, diff --git a/test/behavior/return_address.zig b/test/behavior/return_address.zig index 3e8c18c04ae9..749dd110d5ec 100644 --- a/test/behavior/return_address.zig +++ b/test/behavior/return_address.zig @@ -6,10 +6,10 @@ fn retAddr() usize { } test "return address" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; _ = retAddr(); // TODO: #14938 diff --git a/test/behavior/saturating_arithmetic.zig b/test/behavior/saturating_arithmetic.zig index 30d1aa712e34..d145459bea93 100644 --- a/test/behavior/saturating_arithmetic.zig +++ b/test/behavior/saturating_arithmetic.zig @@ -5,10 +5,10 @@ const maxInt = std.math.maxInt; const expect = std.testing.expect; test "saturating add" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -51,12 +51,12 @@ test "saturating add" { } test "saturating add 128bit" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -78,10 +78,10 @@ test "saturating add 128bit" { } test "saturating subtraction" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -123,12 +123,12 @@ test "saturating subtraction" { } test "saturating subtraction 128bit" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -151,15 +151,15 @@ test "saturating subtraction 128bit" { } test "saturating multiplication" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; - - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .wasm32) { + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .wasm32) { // https://github.com/ziglang/zig/issues/9660 return error.SkipZigTest; } @@ -198,11 +198,11 @@ test "saturating multiplication" { } test "saturating shift-left" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -238,11 +238,11 @@ test "saturating shift-left" { } test "saturating shl uses the LHS type" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const lhs_const: u8 = 1; var lhs_var: u8 = 1; diff --git a/test/behavior/select.zig b/test/behavior/select.zig index 66cc0a49b019..115d13f33882 100644 --- a/test/behavior/select.zig +++ b/test/behavior/select.zig @@ -4,12 +4,12 @@ const mem = std.mem; const expect = std.testing.expect; test "@select vectors" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime selectVectors(); try selectVectors(); @@ -33,12 +33,12 @@ fn selectVectors() !void { } test "@select arrays" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime selectArrays(); try selectArrays(); diff --git a/test/behavior/shuffle.zig b/test/behavior/shuffle.zig index 6137c66f1f93..6ef01b34117c 100644 --- a/test/behavior/shuffle.zig +++ b/test/behavior/shuffle.zig @@ -4,11 +4,11 @@ const mem = std.mem; const expect = std.testing.expect; test "@shuffle int" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -45,12 +45,12 @@ test "@shuffle int" { } test "@shuffle bool 1" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -66,14 +66,14 @@ test "@shuffle bool 1" { } test "@shuffle bool 2" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_llvm) { + if (builtin.zig_backend == .zsf_llvm) { // https://github.com/ziglang/zig/issues/3246 return error.SkipZigTest; } diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig index a161be66eb05..b0e8812a8531 100644 --- a/test/behavior/sizeof_and_typeof.zig +++ b/test/behavior/sizeof_and_typeof.zig @@ -18,7 +18,7 @@ test "@sizeOf on compile-time types" { } test "@TypeOf() with multiple arguments" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var var_1: u32 = undefined; @@ -76,8 +76,8 @@ const P = packed struct { }; test "@offsetOf" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // Packed structs have fixed memory layout try expect(@offsetOf(P, "a") == 0); @@ -104,7 +104,7 @@ test "@offsetOf" { } test "@bitOffsetOf" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO // Packed structs have fixed memory layout try expect(@bitOffsetOf(P, "a") == 0); @@ -153,7 +153,7 @@ test "@TypeOf() has no runtime side effects" { } test "branching logic inside @TypeOf" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; const S = struct { var data: i32 = 0; @@ -265,10 +265,10 @@ test "bitSizeOf comptime_int" { } test "runtime instructions inside typeof in comptime only scope" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { var y: i8 = 2; diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig index 4316aca34fa5..231e23446a7d 100644 --- a/test/behavior/slice.zig +++ b/test/behavior/slice.zig @@ -28,8 +28,8 @@ comptime { } test "slicing" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var array: [20]i32 = undefined; @@ -64,8 +64,8 @@ test "comptime slice of undefined pointer of length 0" { } test "implicitly cast array of size 0 to slice" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var msg = [_]u8{}; try assertLenIsZero(&msg); @@ -76,7 +76,7 @@ fn assertLenIsZero(msg: []const u8) !void { } test "access len index of sentinel-terminated slice" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -121,8 +121,8 @@ test "slice of type" { } test "generic malloc free" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a = memAlloc(u8, 10) catch unreachable; memFree(u8, a); @@ -172,9 +172,9 @@ test "comptime pointer cast array and then slice" { } test "slicing zero length array" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const s1 = ""[0..]; const s2 = ([_]u32{})[0..]; @@ -185,7 +185,7 @@ test "slicing zero length array" { } test "slicing pointer by length" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 }; const ptr: [*]const u8 = @as([*]const u8, @ptrCast(&array)); @@ -220,8 +220,8 @@ test "slice string literal has correct type" { } test "result location zero sized array inside struct field implicit cast to slice" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const E = struct { entries: []u32, @@ -231,10 +231,10 @@ test "result location zero sized array inside struct field implicit cast to slic } test "runtime safety lets us slice from len..len" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var an_array = [_]u8{ 1, 2, 3 }; try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), "")); @@ -245,9 +245,9 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 { } test "C pointer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf"; var len: u32 = 10; @@ -256,10 +256,10 @@ test "C pointer" { } test "C pointer slice access" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buf: [10]u32 = [1]u32{42} ** 10; const c_ptr = @as([*c]const u32, @ptrCast(&buf)); @@ -287,9 +287,9 @@ fn sliceSum(comptime q: []const u8) i32 { } test "slice type with custom alignment" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const LazilyResolvedType = struct { anything: i32, @@ -302,8 +302,8 @@ test "slice type with custom alignment" { } test "obtaining a null terminated slice" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // here we have a normal array var buf: [50]u8 = undefined; @@ -344,9 +344,9 @@ test "empty array to slice" { } test "@ptrCast slice to pointer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -362,10 +362,10 @@ test "@ptrCast slice to pointer" { } test "slice syntax resulting in pointer-to-array" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -570,9 +570,9 @@ test "slice syntax resulting in pointer-to-array" { } test "slice pointer-to-array null terminated" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; @@ -590,8 +590,8 @@ test "slice pointer-to-array null terminated" { } test "slice pointer-to-array zero length" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { { @@ -623,10 +623,10 @@ test "slice pointer-to-array zero length" { } test "type coercion of pointer to anon struct literal to pointer to slice" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const U = union { @@ -678,7 +678,7 @@ test "array mult of slice gives ptr to array" { } test "slice bounds in comptime concatenation" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const bs = comptime blk: { const b = "........1........"; @@ -712,9 +712,9 @@ test "slice sentinel access at comptime" { } test "slicing array with sentinel as end index" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn do() !void { @@ -731,9 +731,9 @@ test "slicing array with sentinel as end index" { } test "slicing slice with sentinel as end index" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn do() !void { @@ -762,7 +762,7 @@ test "slice len modification at comptime" { } test "slice field ptr const" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const const_slice: []const u8 = "string"; @@ -776,8 +776,8 @@ test "slice field ptr const" { } test "slice field ptr var" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var var_slice: []const u8 = "string"; @@ -791,10 +791,10 @@ test "slice field ptr var" { } test "global slice field access" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { var slice: []const u8 = undefined; @@ -806,7 +806,7 @@ test "global slice field access" { } test "slice of void" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var n: usize = 10; var arr: [12]void = undefined; @@ -815,7 +815,7 @@ test "slice of void" { } test "slice with dereferenced value" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: usize = 0; var idx: *usize = &a; @@ -831,8 +831,8 @@ test "slice with dereferenced value" { } test "empty slice ptr is non null" { - if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { const empty_slice: []u8 = &[_]u8{}; @@ -849,9 +849,9 @@ test "empty slice ptr is non null" { } test "slice decays to many pointer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var buf: [8]u8 = "abcdefg\x00".*; const p: [*:0]const u8 = buf[0..7 :0]; @@ -859,10 +859,10 @@ test "slice decays to many pointer" { } test "write through pointer to optional slice arg" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn bar(foo: *?[]const u8) !void { @@ -879,10 +879,10 @@ test "write through pointer to optional slice arg" { } test "modify slice length at comptime" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const arr: [2]u8 = .{ 10, 20 }; comptime var s: []const u8 = arr[0..0]; diff --git a/test/behavior/src.zig b/test/behavior/src.zig index 9c81bcde89a3..bc86dd2534ee 100644 --- a/test/behavior/src.zig +++ b/test/behavior/src.zig @@ -14,10 +14,10 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test "@src" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try doTheTest(); } @@ -34,7 +34,7 @@ test "@src used as a comptime parameter" { } test "@src in tuple passed to anytype function" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn Foo(a: anytype) u32 { diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig index 636ac8c2a5e6..52e85eb1c93a 100644 --- a/test/behavior/struct.zig +++ b/test/behavior/struct.zig @@ -10,8 +10,8 @@ const maxInt = std.math.maxInt; top_level_field: i32, test "top level fields" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var instance = @This(){ .top_level_field = 1234, @@ -44,7 +44,7 @@ const StructWithFields = struct { }; test "non-packed struct has fields padded out to the required alignment" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; const foo = StructWithFields{ .a = 5, .b = 1, .c = 10, .d = 2 }; try expect(foo.first() == 5); @@ -67,7 +67,7 @@ const SmallStruct = struct { }; test "lower unnamed constants" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var foo = SmallStruct{ .a = 1, .b = 255 }; try expect(foo.first() == 1); @@ -87,10 +87,10 @@ const StructFoo = struct { }; test "structs" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo: StructFoo = undefined; @memset(@as([*]u8, @ptrCast(&foo))[0..@sizeOf(StructFoo)], 0); @@ -108,8 +108,8 @@ fn testMutation(foo: *StructFoo) void { } test "struct byval assign" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo1: StructFoo = undefined; var foo2: StructFoo = undefined; @@ -129,7 +129,7 @@ test "call struct static method" { const should_be_11 = StructWithNoFields.add(5, 6); test "invoke static method in global scope" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(should_be_11 == 11); } @@ -144,7 +144,7 @@ fn returnEmptyStructInstance() StructWithNoFields { } test "fn call of struct field" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const Foo = struct { ptr: fn () i32, @@ -175,7 +175,7 @@ const MemberFnTestFoo = struct { }; test "call member function directly" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const instance = MemberFnTestFoo{ .x = 1234 }; const result = MemberFnTestFoo.member(instance); @@ -183,7 +183,7 @@ test "call member function directly" { } test "store member function in variable" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const instance = MemberFnTestFoo{ .x = 1234 }; const memberFn = MemberFnTestFoo.member; @@ -203,8 +203,8 @@ const MemberFnRand = struct { }; test "return struct byval from function" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const bar = makeBar2(1234, 5678); try expect(bar.y == 5678); @@ -251,9 +251,9 @@ test "usingnamespace within struct scope" { } test "struct field init with catch" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -279,7 +279,7 @@ const blah: packed struct { } = undefined; test "bit field alignment" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(@TypeOf(&blah.b) == *align(1:3:1) const u3); } @@ -294,9 +294,9 @@ const Val = struct { }; test "struct point to self" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var root: Node = undefined; root.val.x = 1; @@ -311,9 +311,9 @@ test "struct point to self" { } test "void struct fields" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const foo = VoidStructFieldsFoo{ .a = void{}, @@ -330,7 +330,7 @@ const VoidStructFieldsFoo = struct { }; test "return empty struct from fn" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO _ = testReturnEmptyStructFromFn(); } @@ -340,8 +340,8 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 { } test "pass slice of empty struct to fn" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1); } @@ -350,10 +350,10 @@ fn testPassSliceOfEmptyStructToFn(slice: []const EmptyStruct2) usize { } test "self-referencing struct via array member" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = struct { children: [1]*@This(), @@ -364,7 +364,7 @@ test "self-referencing struct via array member" { } test "empty struct method call" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const es = EmptyStruct{}; try expect(es.method() == 1234); @@ -377,8 +377,8 @@ const EmptyStruct = struct { }; test "align 1 field before self referential align 8 field as slice return type" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const result = alloc(Expr); try expect(result.len == 0); @@ -399,10 +399,10 @@ const APackedStruct = packed struct { }; test "packed struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo = APackedStruct{ .x = 1, @@ -424,13 +424,13 @@ const Foo96Bits = packed struct { }; test "packed struct 24bits" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO if (builtin.cpu.arch == .wasm32) return error.SkipZigTest; // TODO if (comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { std.debug.assert(@sizeOf(Foo24Bits) == @sizeOf(u24)); @@ -469,10 +469,10 @@ test "packed struct 24bits" { } test "runtime struct initialization of bitfield" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const s1 = Nibbles{ .x = x1, @@ -508,10 +508,10 @@ const Bitfields = packed struct { }; test "packed struct fields are ordered from LSB to MSB" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var all: u64 = 0x7765443322221111; var bytes: [8]u8 align(@alignOf(Bitfields)) = undefined; @@ -528,10 +528,10 @@ test "packed struct fields are ordered from LSB to MSB" { } test "implicit cast packed struct field to const ptr" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const LevelUpMove = packed struct { move_id: u9, @@ -549,8 +549,8 @@ test "implicit cast packed struct field to const ptr" { } test "zero-bit field in packed struct" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = packed struct { x: u10, @@ -561,13 +561,13 @@ test "zero-bit field in packed struct" { } test "packed struct with non-ABI-aligned field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - 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 - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = packed struct { x: u9, @@ -593,10 +593,10 @@ const bit_field_1 = BitField1{ }; test "bit field access" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var data = bit_field_1; try expect(getA(&data) == 1); @@ -625,8 +625,8 @@ fn getC(data: *const BitField1) u2 { } test "default struct initialization fields" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { a: i32 = 1234, @@ -648,10 +648,10 @@ test "default struct initialization fields" { } test "packed array 24bits" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { try expect(@sizeOf([9]Foo32Bits) == 9 * 4); @@ -715,10 +715,10 @@ const FooArrayOfAligned = packed struct { }; test "pointer to packed struct member in a stack variable" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = packed struct { a: u2, @@ -733,7 +733,7 @@ test "pointer to packed struct member in a stack variable" { } test "packed struct with u0 field access" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = packed struct { f0: u0, @@ -743,9 +743,9 @@ test "packed struct with u0 field access" { } test "access to global struct fields" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; g_foo.bar.value = 42; try expect(g_foo.bar.value == 42); @@ -766,11 +766,11 @@ const S0 = struct { var g_foo: S0 = S0.init(); test "packed struct with fp fields" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = packed struct { data0: f32, @@ -795,9 +795,9 @@ test "packed struct with fp fields" { } test "fn with C calling convention returns struct by value" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn entry() !void { @@ -820,11 +820,11 @@ test "fn with C calling convention returns struct by value" { } test "non-packed struct with u128 entry in union" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; const U = union(enum) { Num: u128, @@ -845,10 +845,10 @@ test "non-packed struct with u128 entry in union" { } test "packed struct field passed to generic function" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const P = packed struct { @@ -870,8 +870,8 @@ test "packed struct field passed to generic function" { } test "anonymous struct literal syntax" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { const Point = struct { @@ -942,9 +942,9 @@ test "tuple assigned to variable" { } test "comptime struct field" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO if (comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; // TODO const T = struct { @@ -959,10 +959,10 @@ test "comptime struct field" { } test "tuple element initialized with fn call" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -978,10 +978,10 @@ test "tuple element initialized with fn call" { } test "struct with union field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Value = struct { ref: u32 = 2, @@ -999,10 +999,10 @@ test "struct with union field" { } test "type coercion of anon struct literal to struct" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const S2 = struct { @@ -1037,10 +1037,10 @@ test "type coercion of anon struct literal to struct" { } test "type coercion of pointer to anon struct literal to pointer to struct" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const S2 = struct { @@ -1075,11 +1075,11 @@ test "type coercion of pointer to anon struct literal to pointer to struct" { } test "packed struct with undefined initializers" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const P = packed struct { @@ -1107,8 +1107,8 @@ test "packed struct with undefined initializers" { } test "for loop over pointers to struct, getting field from struct pointer" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { const Foo = struct { @@ -1145,10 +1145,10 @@ test "for loop over pointers to struct, getting field from struct pointer" { } test "anon init through error unions and optionals" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { a: u32, @@ -1172,10 +1172,10 @@ test "anon init through error unions and optionals" { } test "anon init through optional" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { a: u32, @@ -1192,10 +1192,10 @@ test "anon init through optional" { } test "anon init through error union" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { a: u32, @@ -1212,10 +1212,10 @@ test "anon init through error union" { } test "typed init through error unions and optionals" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { a: u32, @@ -1239,8 +1239,8 @@ test "typed init through error unions and optionals" { } test "initialize struct with empty literal" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { x: i32 = 1234 }; var s: S = .{}; @@ -1248,7 +1248,7 @@ test "initialize struct with empty literal" { } test "loading a struct pointer perfoms a copy" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { a: i32, @@ -1273,10 +1273,10 @@ test "loading a struct pointer perfoms a copy" { } test "packed struct aggregate init" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo(a: i2, b: i6) u8 { @@ -1293,10 +1293,10 @@ test "packed struct aggregate init" { } test "packed struct field access via pointer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1334,8 +1334,8 @@ test "store to comptime field" { } test "struct field init value is size of the struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const namespace = struct { const S = extern struct { @@ -1348,10 +1348,10 @@ test "struct field init value is size of the struct" { } test "under-aligned struct field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = extern union { fd: i32, @@ -1370,9 +1370,9 @@ test "under-aligned struct field" { } test "fieldParentPtr of a zero-bit field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn testStruct(comptime A: type) !void { @@ -1419,8 +1419,8 @@ test "fieldParentPtr of a zero-bit field" { } test "struct field has a pointer to an aligned version of itself" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const E = struct { next: *align(1) @This(), @@ -1432,7 +1432,7 @@ test "struct field has a pointer to an aligned version of itself" { } test "struct has only one reference" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn optionalStructParam(_: ?struct { x: u8 }) void {} @@ -1480,9 +1480,9 @@ test "struct has only one reference" { } test "no dependency loop on pointer to optional struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const A = struct { b: B }; @@ -1502,8 +1502,8 @@ test "discarded struct initialization works as expected" { } test "function pointer in struct returns the struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const A = struct { const A = @This(); @@ -1518,8 +1518,8 @@ test "function pointer in struct returns the struct" { } test "no dependency loop on optional field wrapped in generic function" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn Atomic(comptime T: type) type { @@ -1537,9 +1537,9 @@ test "no dependency loop on optional field wrapped in generic function" { } test "optional field init with tuple" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { a: ?struct { b: u32 }, @@ -1552,8 +1552,8 @@ test "optional field init with tuple" { } test "if inside struct init inside if" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const MyStruct = struct { x: u32 }; const b: u32 = 5; @@ -1580,7 +1580,7 @@ test "optional generic function label struct field" { } test "struct fields get automatically reordered" { - if (builtin.zig_backend != .stage2_llvm) return error.SkipZigTest; // TODO + if (builtin.zig_backend != .zsf_llvm) return error.SkipZigTest; // TODO const S1 = struct { a: u32, @@ -1638,13 +1638,13 @@ test "instantiate struct with comptime field" { } test "struct field pointer has correct alignment" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -1671,13 +1671,13 @@ test "struct field pointer has correct alignment" { } test "extern struct field pointer has correct alignment" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { diff --git a/test/behavior/struct_contains_null_ptr_itself.zig b/test/behavior/struct_contains_null_ptr_itself.zig index ded29039c8bd..1868050108cf 100644 --- a/test/behavior/struct_contains_null_ptr_itself.zig +++ b/test/behavior/struct_contains_null_ptr_itself.zig @@ -3,9 +3,9 @@ const expect = std.testing.expect; const builtin = @import("builtin"); test "struct contains null pointer which contains original struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: ?*NodeLineComment = null; try expect(x == null); diff --git a/test/behavior/struct_contains_slice_of_itself.zig b/test/behavior/struct_contains_slice_of_itself.zig index 6f63bfb8deed..ffa3dfb41802 100644 --- a/test/behavior/struct_contains_slice_of_itself.zig +++ b/test/behavior/struct_contains_slice_of_itself.zig @@ -12,8 +12,8 @@ const NodeAligned = struct { }; test "struct contains slice of itself" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var other_nodes = [_]Node{ Node{ @@ -52,9 +52,9 @@ test "struct contains slice of itself" { } test "struct contains aligned slice of itself" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var other_nodes = [_]NodeAligned{ NodeAligned{ diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig index 7d90247a30ef..b37a617da73f 100644 --- a/test/behavior/switch.zig +++ b/test/behavior/switch.zig @@ -6,7 +6,7 @@ const expectError = std.testing.expectError; const expectEqual = std.testing.expectEqual; test "switch with numbers" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testSwitchWithNumbers(13); } @@ -21,7 +21,7 @@ fn testSwitchWithNumbers(x: u32) !void { } test "switch with all ranges" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(testSwitchWithAllRanges(50, 3) == 1); try expect(testSwitchWithAllRanges(101, 0) == 2); @@ -54,7 +54,7 @@ test "implicit comptime switch" { } test "switch on enum" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const fruit = Fruit.Orange; nonConstSwitchOnEnum(fruit); @@ -73,7 +73,7 @@ fn nonConstSwitchOnEnum(fruit: Fruit) void { } test "switch statement" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try nonConstSwitch(SwitchStatementFoo.C); } @@ -89,7 +89,7 @@ fn nonConstSwitch(foo: SwitchStatementFoo) !void { const SwitchStatementFoo = enum { A, B, C, D }; test "switch with multiple expressions" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const x = switch (returnsFive()) { 1, 2, 3 => 1, @@ -103,7 +103,7 @@ fn returnsFive() i32 { } test "switch on type" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(trueIfBoolFalseOtherwise(bool)); try expect(!trueIfBoolFalseOtherwise(i32)); @@ -117,8 +117,8 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool { } test "switching on booleans" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testSwitchOnBools(); try comptime testSwitchOnBools(); @@ -171,7 +171,7 @@ test "undefined.u0" { } test "switch with disjoint range" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var q: u8 = 0; switch (q) { @@ -215,7 +215,7 @@ fn poll() void { } test "switch on global mutable var isn't constant-folded" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO while (state < 2) { poll(); @@ -229,10 +229,10 @@ const SwitchProngWithVarEnum = union(enum) { }; test "switch prong with variable" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 }); try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 }); @@ -254,10 +254,10 @@ fn switchProngWithVarFn(a: SwitchProngWithVarEnum) !void { } test "switch on enum using pointer capture" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testSwitchEnumPtrCapture(); try comptime testSwitchEnumPtrCapture(); @@ -276,7 +276,7 @@ fn testSwitchEnumPtrCapture() !void { } test "switch handles all cases of number" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testSwitchHandleAllCases(); try comptime testSwitchHandleAllCases(); @@ -315,10 +315,10 @@ fn testSwitchHandleAllCasesRange(x: u8) u8 { } test "switch on union with some prongs capturing" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const X = union(enum) { a, @@ -353,9 +353,9 @@ test "switch on const enum with var" { } test "anon enum literal used in switch on union enum" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Foo = union(enum) { a: i32, @@ -370,7 +370,7 @@ test "anon enum literal used in switch on union enum" { } test "switch all prongs unreachable" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testAllProngsUnreachable(); try comptime testAllProngsUnreachable(); @@ -393,8 +393,8 @@ fn switchWithUnreachable(x: i32) i32 { } test "capture value of switch with all unreachable prongs" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const x = return_a_number() catch |err| switch (err) { else => unreachable, @@ -407,8 +407,8 @@ fn return_a_number() anyerror!i32 { } test "switch on integer with else capturing expr" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -425,10 +425,10 @@ test "switch on integer with else capturing expr" { } test "else prong of switch on error set excludes other cases" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -460,10 +460,10 @@ test "else prong of switch on error set excludes other cases" { } test "switch prongs with error set cases make a new error set type for capture value" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -497,8 +497,8 @@ test "switch prongs with error set cases make a new error set type for capture v } test "return result loc and then switch with range implicit casted to error union" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -516,9 +516,9 @@ test "return result loc and then switch with range implicit casted to error unio } test "switch with null and T peer types and inferred result location type" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest(c: u8) !void { @@ -536,10 +536,10 @@ test "switch with null and T peer types and inferred result location type" { } test "switch prongs with cases with identical payload types" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Union = union(enum) { A: usize, @@ -581,9 +581,9 @@ test "switch prongs with cases with identical payload types" { } test "switch on pointer type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const X = struct { @@ -628,10 +628,10 @@ test "switch on error set with single else" { } test "switch capture copies its payload" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -654,7 +654,7 @@ test "switch capture copies its payload" { } test "capture of integer forwards the switch condition directly" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn foo(x: u8) !void { @@ -675,7 +675,7 @@ test "capture of integer forwards the switch condition directly" { } test "enum value without tag name used as switch item" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const E = enum(u32) { a = 1, @@ -706,7 +706,7 @@ test "switch item sizeof" { } test "comptime inline switch" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union(enum) { a: type, b: type }; const value = comptime blk: { @@ -720,7 +720,7 @@ test "comptime inline switch" { } test "switch capture peer type resolution" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union(enum) { a: u32, @@ -737,7 +737,7 @@ test "switch capture peer type resolution" { } test "switch capture peer type resolution for in-memory coercible payloads" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T1 = c_int; const T2 = @Type(@typeInfo(T1)); @@ -759,7 +759,7 @@ test "switch capture peer type resolution for in-memory coercible payloads" { } test "switch pointer capture peer type resolution" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T1 = c_int; const T2 = @Type(@typeInfo(T1)); @@ -787,7 +787,7 @@ test "switch pointer capture peer type resolution" { } test "inline switch range that includes the maximum value of the switched type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const inputs: [3]u8 = .{ 0, 254, 255 }; for (inputs) |input| { diff --git a/test/behavior/switch_prong_err_enum.zig b/test/behavior/switch_prong_err_enum.zig index f09e2fb7d36c..11259d62ac6e 100644 --- a/test/behavior/switch_prong_err_enum.zig +++ b/test/behavior/switch_prong_err_enum.zig @@ -21,10 +21,10 @@ fn doThing(form_id: u64) anyerror!FormValue { } test "switch prong returns error enum" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; switch (doThing(17) catch unreachable) { FormValue.Address => |payload| { diff --git a/test/behavior/switch_prong_implicit_cast.zig b/test/behavior/switch_prong_implicit_cast.zig index 4be8f8208515..ca84ffb3d55f 100644 --- a/test/behavior/switch_prong_implicit_cast.zig +++ b/test/behavior/switch_prong_implicit_cast.zig @@ -15,10 +15,10 @@ fn foo(id: u64) !FormValue { } test "switch prong implicit cast" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const result = switch (foo(2) catch unreachable) { FormValue.One => false, diff --git a/test/behavior/this.zig b/test/behavior/this.zig index 0bc765c8a715..1eafb1034785 100644 --- a/test/behavior/this.zig +++ b/test/behavior/this.zig @@ -25,9 +25,9 @@ test "this refer to module call private fn" { } test "this refer to container" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var pt: Point(i32) = undefined; pt.x = 12; diff --git a/test/behavior/threadlocal.zig b/test/behavior/threadlocal.zig index 9a6e0542e87d..23997b33f9e2 100644 --- a/test/behavior/threadlocal.zig +++ b/test/behavior/threadlocal.zig @@ -3,16 +3,16 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test "thread local variable" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_llvm) switch (builtin.cpu.arch) { + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_llvm) switch (builtin.cpu.arch) { .x86_64, .x86 => {}, else => return error.SkipZigTest, }; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .macos) { + if (builtin.zig_backend == .zsf_x86_64 and builtin.os.tag == .macos) { // Fails due to register hazards. return error.SkipZigTest; } @@ -25,15 +25,15 @@ test "thread local variable" { } test "pointer to thread local array" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_llvm) switch (builtin.cpu.arch) { + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_llvm) switch (builtin.cpu.arch) { .x86_64, .x86 => {}, else => return error.SkipZigTest, }; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const s = "Hello world"; std.mem.copy(u8, buffer[0..], s); @@ -43,14 +43,14 @@ test "pointer to thread local array" { threadlocal var buffer: [11]u8 = undefined; test "reference a global threadlocal variable" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_llvm) switch (builtin.cpu.arch) { + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_llvm) switch (builtin.cpu.arch) { .x86_64, .x86 => {}, else => return error.SkipZigTest, }; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO _ = nrfx_uart_rx(&g_uart0); } diff --git a/test/behavior/translate_c_macros.zig b/test/behavior/translate_c_macros.zig index 68e91bfa5819..0f1f13a7a361 100644 --- a/test/behavior/translate_c_macros.zig +++ b/test/behavior/translate_c_macros.zig @@ -8,8 +8,8 @@ const h = @cImport(@cInclude("behavior/translate_c_macros.h")); const latin1 = @cImport(@cInclude("behavior/translate_c_macros_not_utf8.h")); test "casting to void with a macro" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; h.IGNORE_ME_1(42); h.IGNORE_ME_2(42); @@ -24,10 +24,10 @@ test "casting to void with a macro" { } test "initializer list expression" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqual(h.Color{ .r = 200, @@ -38,37 +38,37 @@ test "initializer list expression" { } test "sizeof in macros" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF(u32)); try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF2(u32)); } test "reference to a struct type" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(@sizeOf(h.struct_Foo) == h.SIZE_OF_FOO); } test "cast negative integer to pointer" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqual(@as(?*anyopaque, @ptrFromInt(@as(usize, @bitCast(@as(isize, -1))))), h.MAP_FAILED); } test "casting to union with a macro" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const l: c_long = 42; const d: f64 = 2.0; @@ -81,11 +81,11 @@ test "casting to union with a macro" { } test "casting or calling a value with a paren-surrounded macro" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const l: c_long = 42; const casted = h.CAST_OR_CALL_WITH_PARENS(c_int, l); @@ -101,22 +101,22 @@ test "casting or calling a value with a paren-surrounded macro" { } test "nested comma operator" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR); try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR_LHS); } test "cast functions" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo() void {} @@ -126,43 +126,43 @@ test "cast functions" { } test "large integer macro" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqual(@as(c_ulonglong, 18446744073709550592), h.LARGE_INT); } test "string literal macro with embedded tab character" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqualStrings("hello\t", h.EMBEDDED_TAB); } test "string and char literals that are not UTF-8 encoded. Issue #12784" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqual(@as(u8, '\xA9'), latin1.UNPRINTABLE_CHAR); try expectEqualStrings("\xA9\xA9\xA9", latin1.UNPRINTABLE_STRING); } test "Macro that uses division operator. Issue #13162" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqual(@as(c_int, 42), h.DIVIDE_CONSTANT(@as(c_int, 42_000))); try expectEqual(@as(c_uint, 42), h.DIVIDE_CONSTANT(@as(c_uint, 42_000))); @@ -192,11 +192,11 @@ test "Macro that uses division operator. Issue #13162" { } test "Macro that uses remainder operator. Issue #13346" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqual(@as(c_int, 2_010), h.REMAINDER_CONSTANT(@as(c_int, 42_010))); try expectEqual(@as(c_uint, 2_030), h.REMAINDER_CONSTANT(@as(c_uint, 42_030))); @@ -227,7 +227,7 @@ test "Macro that uses remainder operator. Issue #13346" { } test "@typeInfo on @cImport result" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(@typeInfo(h).Struct.decls.len > 1); } diff --git a/test/behavior/truncate.zig b/test/behavior/truncate.zig index 4fc095b66c42..0aa9dfd14856 100644 --- a/test/behavior/truncate.zig +++ b/test/behavior/truncate.zig @@ -60,11 +60,11 @@ test "truncate on comptime integer" { } test "truncate on vectors" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { diff --git a/test/behavior/try.zig b/test/behavior/try.zig index c7b0396051b8..438cea323670 100644 --- a/test/behavior/try.zig +++ b/test/behavior/try.zig @@ -3,8 +3,8 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test "try on error union" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try tryOnErrorUnionImpl(); try comptime tryOnErrorUnionImpl(); @@ -24,7 +24,7 @@ fn returnsTen() anyerror!i32 { } test "try without vars" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const result1 = if (failIfTrue(true)) 1 else |_| @as(i32, 2); try expect(result1 == 2); @@ -42,7 +42,7 @@ fn failIfTrue(ok: bool) anyerror!void { } test "try then not executed with assignment" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (failIfTrue(true)) { unreachable; diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig index 32ebfe89fdfa..4eca1107ef38 100644 --- a/test/behavior/tuple.zig +++ b/test/behavior/tuple.zig @@ -7,10 +7,10 @@ const expectEqualStrings = std.testing.expectEqualStrings; const expectEqual = std.testing.expectEqual; test "tuple concatenation" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -51,10 +51,10 @@ test "tuple multiplication" { } test "more tuple concatenation" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = struct { fn consume_tuple(tuple: anytype, len: usize) !void { @@ -129,8 +129,8 @@ test "tuple initializer for var" { } test "array-like initializer for tuple types" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const T = @Type(.{ .Struct = .{ @@ -212,10 +212,10 @@ test "initializing anon struct with explicit type" { } test "fieldParentPtr of tuple" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u32 = 0; const tuple = .{ x, x }; @@ -223,10 +223,10 @@ test "fieldParentPtr of tuple" { } test "fieldParentPtr of anon struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u32 = 0; const anon_st = .{ .foo = x, .bar = x }; @@ -246,8 +246,8 @@ test "offsetOf anon struct" { } test "initializing tuple with mixed comptime-runtime fields" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u32 = 15; const T = @TypeOf(.{ @as(i32, -1234), @as(u32, 5678), x }); @@ -256,8 +256,8 @@ test "initializing tuple with mixed comptime-runtime fields" { } test "initializing anon struct with mixed comptime-runtime fields" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: u32 = 15; const T = @TypeOf(.{ .foo = @as(i32, -1234), .bar = x }); @@ -266,10 +266,10 @@ test "initializing anon struct with mixed comptime-runtime fields" { } test "tuple in tuple passed to generic function" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn pair(x: f32, y: f32) std.meta.Tuple(&.{ f32, f32 }) { @@ -286,10 +286,10 @@ test "tuple in tuple passed to generic function" { } test "coerce tuple to tuple" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = std.meta.Tuple(&.{u8}); const S = struct { @@ -301,10 +301,10 @@ test "coerce tuple to tuple" { } test "tuple type with void field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = std.meta.Tuple(&[_]type{void}); const x = T{{}}; @@ -312,7 +312,7 @@ test "tuple type with void field" { } test "zero sized struct in tuple handled correctly" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const State = struct { const Self = @This(); @@ -341,9 +341,9 @@ test "zero sized struct in tuple handled correctly" { } test "tuple type with void field and a runtime field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = std.meta.Tuple(&[_]type{ usize, void }); var t: T = .{ 5, {} }; @@ -351,10 +351,10 @@ test "tuple type with void field and a runtime field" { } test "branching inside tuple literal" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn foo(a: anytype) !void { @@ -366,10 +366,10 @@ test "branching inside tuple literal" { } test "tuple initialized with a runtime known value" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const E = union(enum) { e: []const u8 }; const W = union(enum) { w: E }; @@ -379,12 +379,12 @@ test "tuple initialized with a runtime known value" { } test "tuple of struct concatenation and coercion to array" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const StructWithDefault = struct { value: f32 = 42 }; const SomeStruct = struct { array: [4]StructWithDefault }; @@ -396,10 +396,10 @@ test "tuple of struct concatenation and coercion to array" { } test "nested runtime conditionals in tuple initializer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var data: u8 = 0; const x = .{ @@ -431,10 +431,10 @@ test "sentinel slice in tuple" { } test "tuple pointer is indexable" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { u32, bool }; @@ -455,11 +455,11 @@ test "tuple pointer is indexable" { } test "coerce anon tuple to tuple" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; var x: u8 = 1; var y: u16 = 2; diff --git a/test/behavior/tuple_declarations.zig b/test/behavior/tuple_declarations.zig index 1936d770432d..1294aa13d686 100644 --- a/test/behavior/tuple_declarations.zig +++ b/test/behavior/tuple_declarations.zig @@ -5,9 +5,9 @@ const expect = testing.expect; const expectEqualStrings = testing.expectEqualStrings; test "tuple declaration type info" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; { const T = struct { comptime u32 align(2) = 1, []const u8 }; @@ -34,9 +34,9 @@ test "tuple declaration type info" { } test "Tuple declaration usage" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = struct { u32, []const u8 }; var t: T = .{ 1, "foo" }; diff --git a/test/behavior/type.zig b/test/behavior/type.zig index a2ede838b263..b688d627eb0c 100644 --- a/test/behavior/type.zig +++ b/test/behavior/type.zig @@ -199,11 +199,11 @@ test "Type.ErrorUnion" { } test "Type.Opaque" { - if (builtin.zig_backend == .stage2_wasm) 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Opaque = @Type(.{ .Opaque = .{ @@ -258,10 +258,10 @@ test "Type.ErrorSet" { } test "Type.Struct" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const A = @Type(@typeInfo(struct { x: u8, y: u32 })); const infoA = @typeInfo(A).Struct; @@ -347,9 +347,9 @@ test "Type.Struct" { } test "Type.Enum" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Foo = @Type(.{ .Enum = .{ @@ -383,10 +383,10 @@ test "Type.Enum" { } test "Type.Union" { - if (builtin.zig_backend == .stage2_wasm) 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Untagged = @Type(.{ .Union = .{ @@ -487,8 +487,8 @@ test "Type.Union from regular enum" { } test "Type.Fn" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO const some_opaque = opaque {}; const some_ptr = *some_opaque; diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig index 421800d6fd0c..00f7d4498b50 100644 --- a/test/behavior/type_info.zig +++ b/test/behavior/type_info.zig @@ -157,10 +157,10 @@ fn testArray() !void { } test "type info: error set, error union info, anyerror" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testErrorSet(); try comptime testErrorSet(); @@ -189,10 +189,10 @@ fn testErrorSet() !void { } test "type info: error set single value" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const TestSet = error.One; @@ -203,10 +203,10 @@ test "type info: error set single value" { } test "type info: error set merged" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const TestSet = error{ One, Two } || error{Three}; @@ -219,10 +219,10 @@ test "type info: error set merged" { } test "type info: enum info" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testEnum(); try comptime testEnum(); @@ -284,7 +284,7 @@ fn testUnion() !void { } test "type info: struct info" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testStruct(); try comptime testStruct(); @@ -352,7 +352,7 @@ fn testOpaque() !void { } test "type info: function type info" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testFunction(); try comptime testFunction(); @@ -510,7 +510,7 @@ test "type info for async frames" { } test "Declarations are returned in declaration order" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { pub const a = 1; @@ -532,8 +532,8 @@ test "Struct.is_tuple for anon list literal" { } test "Struct.is_tuple for anon struct literal" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const info = @typeInfo(@TypeOf(.{ .a = 0 })); try expect(!info.Struct.is_tuple); @@ -568,9 +568,9 @@ test "value from struct @typeInfo default_value can be loaded at comptime" { } test "@typeInfo decls and usingnamespace" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const A = struct { pub const x = 5; diff --git a/test/behavior/typename.zig b/test/behavior/typename.zig index e30f37e5af7c..25c26a696525 100644 --- a/test/behavior/typename.zig +++ b/test/behavior/typename.zig @@ -12,10 +12,10 @@ const expectStringStartsWith = std.testing.expectStringStartsWith; // failures. test "anon fn param" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/9339 try expectEqualStringsIgnoreDigits( @@ -38,10 +38,10 @@ test "anon fn param" { } test "anon field init" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Foo = .{ .T1 = struct {}, @@ -64,10 +64,10 @@ test "anon field init" { } test "basic" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqualStrings("i64", @typeName(i64)); try expectEqualStrings("*usize", @typeName(*usize)); @@ -88,10 +88,10 @@ test "basic" { } test "top level decl" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expectEqualStrings( "behavior.typename.A_Struct", @@ -138,10 +138,10 @@ const B = struct { }; test "fn param" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/675 try expectEqualStrings( @@ -209,10 +209,10 @@ pub fn expectEqualStringsIgnoreDigits(expected: []const u8, actual: []const u8) } test "local variable" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Foo = struct { a: u32 }; const Bar = union { a: u32 }; @@ -228,20 +228,20 @@ test "local variable" { } test "comptime parameters not converted to anytype in function type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = fn (fn (type) void, void) void; try expectEqualStrings("fn(comptime fn(comptime type) void, void) void", @typeName(T)); } test "anon name strategy used in sub expression" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn getTheName() []const u8 { diff --git a/test/behavior/undefined.zig b/test/behavior/undefined.zig index 6c99b4bbcefa..45da804e4f6c 100644 --- a/test/behavior/undefined.zig +++ b/test/behavior/undefined.zig @@ -15,8 +15,8 @@ const static_array = initStaticArray(); test "init static array to undefined" { // This test causes `initStaticArray()` to be codegen'd, and the // C backend does not yet support returning arrays, so it fails - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(static_array[0] == 1); try expect(static_array[4] == 2); @@ -44,10 +44,10 @@ fn setFooX(foo: *Foo) void { } test "assign undefined to struct" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { var foo: Foo = undefined; @@ -62,10 +62,10 @@ test "assign undefined to struct" { } test "assign undefined to struct with method" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; comptime { var foo: Foo = undefined; @@ -80,7 +80,7 @@ test "assign undefined to struct with method" { } test "type name of undefined" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const x = undefined; try expect(mem.eql(u8, @typeName(@TypeOf(x)), "@TypeOf(undefined)")); diff --git a/test/behavior/underscore.zig b/test/behavior/underscore.zig index bb5dd156bc43..2494cb5bb4b3 100644 --- a/test/behavior/underscore.zig +++ b/test/behavior/underscore.zig @@ -7,8 +7,8 @@ test "ignore lval with underscore" { } test "ignore lval with underscore (while loop)" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; while (optionalReturnError()) |_| { while (optionalReturnError()) |_| { diff --git a/test/behavior/union.zig b/test/behavior/union.zig index 3ea6f17a264a..8d825f8516ca 100644 --- a/test/behavior/union.zig +++ b/test/behavior/union.zig @@ -11,10 +11,10 @@ const FooWithFloats = union { }; test "basic unions with floats" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo = FooWithFloats{ .int = 1 }; try expect(foo.int == 1); @@ -27,10 +27,10 @@ fn setFloat(foo: *FooWithFloats, x: f64) void { } test "init union with runtime value - floats" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo: FooWithFloats = undefined; @@ -39,10 +39,10 @@ test "init union with runtime value - floats" { } test "basic unions" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo = Foo{ .int = 1 }; try expect(foo.int == 1); @@ -58,10 +58,10 @@ const Foo = union { }; test "init union with runtime value" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo: Foo = undefined; @@ -98,9 +98,9 @@ const FooExtern = extern union { }; test "basic extern unions" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var foo = FooExtern{ .int = 1 }; try expect(foo.int == 1); @@ -169,10 +169,10 @@ test "access a member of tagged union with conflicting enum tag name" { } test "constant tagged union with payload" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var empty = TaggedUnionWithPayload{ .Empty = {} }; var full = TaggedUnionWithPayload{ .Full = 13 }; @@ -219,20 +219,20 @@ const Payload = union(Letter) { }; test "union with specified enum tag" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try doTest(); try comptime doTest(); } test "packed union generates correctly aligned type" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = packed union { f1: *const fn () error{TestUnexpectedResult}!void, @@ -269,9 +269,9 @@ fn testComparison() !void { } test "comparison between union and enum literal" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testComparison(); try comptime testComparison(); @@ -284,9 +284,9 @@ const TheUnion = union(TheTag) { C: i32, }; test "cast union to tag type of union" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try testCastUnionToTag(); try comptime testCastUnionToTag(); @@ -304,9 +304,9 @@ test "union field access gives the enum values" { } test "cast tag type of union to union" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var x: Value2 = Letter2.B; try expect(@as(Letter2, x) == Letter2.B); @@ -319,9 +319,9 @@ const Value2 = union(Letter2) { }; test "implicit cast union to its tag type" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var x: Value2 = Letter2.B; try expect(x == Letter2.B); @@ -339,10 +339,10 @@ pub const PackThis = union(enum) { }; test "constant packed union" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }}); } @@ -358,9 +358,9 @@ const MultipleChoice = union(enum(u32)) { D = 1000, }; test "simple union(enum(u32))" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var x = MultipleChoice.C; try expect(x == MultipleChoice.C); @@ -383,10 +383,10 @@ test "union with only 1 field which is void should be zero bits" { } test "tagged union initialization with runtime void" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(testTaggedUnionInit({})); } @@ -404,10 +404,10 @@ fn testTaggedUnionInit(x: anytype) bool { pub const UnionEnumNoPayloads = union(enum) { A, B }; test "tagged union with no payloads" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a = UnionEnumNoPayloads{ .B = {} }; switch (a) { @@ -417,7 +417,7 @@ test "tagged union with no payloads" { } test "union with only 1 field casted to its enum type" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const Literal = union(enum) { Number: f64, @@ -450,10 +450,10 @@ const Foo1 = union(enum) { var glbl: Foo1 = undefined; test "global union with single field is correctly initialized" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; glbl = Foo1{ .f = @typeInfo(Foo1).Union.fields[0].type{ .x = 123 }, @@ -469,10 +469,10 @@ pub const FooUnion = union(enum) { var glbl_array: [2]FooUnion = undefined; test "initialize global array of union" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; glbl_array[1] = FooUnion{ .U1 = 2 }; glbl_array[0] = FooUnion{ .U0 = 1 }; @@ -481,10 +481,10 @@ test "initialize global array of union" { } test "update the tag value for zero-sized unions" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = union(enum) { U0: void, @@ -497,10 +497,10 @@ test "update the tag value for zero-sized unions" { } test "union initializer generates padding only if needed" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union(enum) { A: u24, @@ -511,9 +511,9 @@ test "union initializer generates padding only if needed" { } test "runtime tag name with single field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union(enum) { A: i32, @@ -524,10 +524,10 @@ test "runtime tag name with single field" { } test "method call on an empty union" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const MyUnion = union(MyUnionTag) { @@ -566,7 +566,7 @@ const FooNoVoid = union(enum) { const Baz = enum { A, B, C, D }; test "tagged union type" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const foo1 = TaggedFoo{ .One = 13 }; const foo2 = TaggedFoo{ @@ -587,10 +587,10 @@ test "tagged union type" { } test "tagged union as return value" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; switch (returnAnInt(13)) { TaggedFoo.One => |value| try expect(value == 13), @@ -603,10 +603,10 @@ fn returnAnInt(x: i32) TaggedFoo { } test "tagged union with all void fields but a meaningful tag" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const B = union(enum) { @@ -632,10 +632,10 @@ test "tagged union with all void fields but a meaningful tag" { } test "union(enum(u32)) with specified and unspecified tag values" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try comptime expect(Tag(Tag(MultipleChoice2)) == u32); try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 }); @@ -670,10 +670,10 @@ fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void { } test "switch on union with only 1 field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var r: PartialInst = undefined; r = PartialInst.Compiled; @@ -701,8 +701,8 @@ const PartialInstWithPayload = union(enum) { }; test "union with only 1 field casted to its enum type which has enum value specified" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Literal = union(enum) { Number: f64, @@ -726,9 +726,9 @@ test "union with only 1 field casted to its enum type which has enum value speci } test "@intFromEnum works on unions" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const Bar = union(enum) { A: bool, @@ -784,10 +784,10 @@ fn Setter(comptime attr: Attribute) type { } test "return union init with void payload" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn entry() !void { @@ -809,10 +809,10 @@ test "return union init with void payload" { } test "@unionInit stored to a const" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const U = union(enum) { @@ -838,10 +838,10 @@ test "@unionInit stored to a const" { } test "@unionInit can modify a union type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const UnionInitEnum = union(enum) { Boolean: bool, @@ -862,10 +862,10 @@ test "@unionInit can modify a union type" { } test "@unionInit can modify a pointer value" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const UnionInitEnum = union(enum) { Boolean: bool, @@ -883,10 +883,10 @@ test "@unionInit can modify a pointer value" { } test "union no tag with struct member" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Struct = struct {}; const Union = union { @@ -919,10 +919,10 @@ test "extern union doesn't trigger field check at comptime" { } test "anonymous union literal syntax" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Number = union { @@ -946,9 +946,9 @@ test "anonymous union literal syntax" { } test "function call result coerces from tagged union to the tag" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { const Arch = union(enum) { @@ -979,10 +979,10 @@ test "function call result coerces from tagged union to the tag" { } test "cast from anonymous struct to union" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const U = union(enum) { @@ -1011,10 +1011,10 @@ test "cast from anonymous struct to union" { } test "cast from pointer to anonymous struct to pointer to union" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const U = union(enum) { @@ -1043,10 +1043,10 @@ test "cast from pointer to anonymous struct to pointer to union" { } test "switching on non exhaustive union" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const E = enum(u8) { @@ -1071,10 +1071,10 @@ test "switching on non exhaustive union" { } test "containers with single-field enums" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const A = union(enum) { f1 }; @@ -1100,10 +1100,10 @@ test "containers with single-field enums" { } test "@unionInit on union with tag but no fields" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { const Type = enum(u8) { no_op = 105 }; @@ -1149,10 +1149,10 @@ test "union enum type gets a separate scope" { } test "global variable struct contains union initialized to non-most-aligned field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const T = struct { const U = union(enum) { @@ -1176,10 +1176,10 @@ test "global variable struct contains union initialized to non-most-aligned fiel } test "union with no result loc initiated with a runtime value" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union { a: u32, @@ -1193,10 +1193,10 @@ test "union with no result loc initiated with a runtime value" { } test "union with a large struct field" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { a: [8]usize, @@ -1227,10 +1227,10 @@ test "comptime equality of extern unions with same tag" { } test "union tag is set when initiated as a temporary value at runtime" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union(enum) { a, @@ -1246,10 +1246,10 @@ test "union tag is set when initiated as a temporary value at runtime" { } test "extern union most-aligned field is smaller" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = extern union { in6: extern struct { @@ -1265,10 +1265,10 @@ test "extern union most-aligned field is smaller" { } test "return an extern union from C calling convention" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const namespace = struct { const S = extern struct { @@ -1296,10 +1296,10 @@ test "return an extern union from C calling convention" { } test "noreturn field in union" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union(enum) { a: u32, @@ -1348,10 +1348,10 @@ test "noreturn field in union" { } test "union and enum field order doesn't match" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const MyTag = enum(u32) { b = 1337, @@ -1373,10 +1373,10 @@ test "union and enum field order doesn't match" { } test "@unionInit uses tag value instead of field index" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const E = enum(u8) { b = 255, @@ -1400,10 +1400,10 @@ test "@unionInit uses tag value instead of field index" { } test "union field ptr - zero sized payload" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union { foo: void, @@ -1415,10 +1415,10 @@ test "union field ptr - zero sized payload" { } test "union field ptr - zero sized field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union { foo: void, @@ -1430,10 +1430,10 @@ test "union field ptr - zero sized field" { } test "packed union in packed struct" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = packed struct { nested: packed union { @@ -1482,9 +1482,9 @@ test "union int tag type is properly managed" { } test "no dependency loop when function pointer in union returns the union" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union(enum) { const U = @This(); @@ -1503,9 +1503,9 @@ test "no dependency loop when function pointer in union returns the union" { } test "union reassignment can use previous value" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union { a: u32, @@ -1517,10 +1517,10 @@ test "union reassignment can use previous value" { } test "packed union with zero-bit field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = packed struct { nested: packed union { @@ -1537,9 +1537,9 @@ test "packed union with zero-bit field" { } test "reinterpreting enum value inside packed union" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = packed union { tag: enum { a, b }, @@ -1556,8 +1556,8 @@ test "reinterpreting enum value inside packed union" { } test "access the tag of a global tagged union" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union(enum) { a, @@ -1568,8 +1568,8 @@ test "access the tag of a global tagged union" { } test "coerce enum literal to union in result loc" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const U = union(enum) { a, @@ -1585,13 +1585,13 @@ test "coerce enum literal to union in result loc" { } test "defined-layout union field pointer has correct alignment" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest(comptime U: type) !void { @@ -1623,13 +1623,13 @@ test "defined-layout union field pointer has correct alignment" { } test "undefined-layout union field pointer has correct alignment" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest(comptime U: type) !void { @@ -1661,13 +1661,13 @@ test "undefined-layout union field pointer has correct alignment" { } test "packed union field pointer has correct alignment" { - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const U = packed union { x: u20 }; const S = packed struct(u24) { a: u2, u: U, b: u2 }; diff --git a/test/behavior/union_with_members.zig b/test/behavior/union_with_members.zig index 186a30ad633a..149ec519b3ba 100644 --- a/test/behavior/union_with_members.zig +++ b/test/behavior/union_with_members.zig @@ -17,10 +17,10 @@ const ET = union(enum) { }; test "enum with members" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a = ET{ .SINT = -42 }; const b = ET{ .UINT = 42 }; diff --git a/test/behavior/usingnamespace.zig b/test/behavior/usingnamespace.zig index 212edb353de3..3da49e95e754 100644 --- a/test/behavior/usingnamespace.zig +++ b/test/behavior/usingnamespace.zig @@ -37,8 +37,8 @@ test "usingnamespace does not redeclare an imported variable" { usingnamespace @import("usingnamespace/foo.zig"); test "usingnamespace omits mixing in private functions" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(@This().privateFunction()); try expect(!@This().printText()); @@ -53,16 +53,16 @@ test { usingnamespace @import("usingnamespace/a.zig"); test "two files usingnamespace import each other" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(@This().ok()); } test { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const AA = struct { x: i32, diff --git a/test/behavior/usingnamespace/import_segregation.zig b/test/behavior/usingnamespace/import_segregation.zig index 9afa0b8fdea8..12a8e1b25d87 100644 --- a/test/behavior/usingnamespace/import_segregation.zig +++ b/test/behavior/usingnamespace/import_segregation.zig @@ -5,7 +5,7 @@ usingnamespace @import("foo.zig"); usingnamespace @import("bar.zig"); test "no clobbering happened" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO @This().foo_function(); @This().bar_function(); diff --git a/test/behavior/var_args.zig b/test/behavior/var_args.zig index df89b4b88c62..4ae6017bb152 100644 --- a/test/behavior/var_args.zig +++ b/test/behavior/var_args.zig @@ -28,8 +28,8 @@ test "send void arg to var args" { } test "pass args directly" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10); try expect(addSomeStuff(.{@as(i32, 1234)}) == 1234); @@ -41,9 +41,9 @@ fn addSomeStuff(args: anytype) i32 { } test "runtime parameter before var args" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect((try extraFn(10, .{})) == 0); try expect((try extraFn(10, .{false})) == 1); @@ -95,12 +95,12 @@ fn doNothingWithFirstArg(args: anytype) void { } test "simple variadic function" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (builtin.os.tag != .macos and comptime builtin.cpu.arch.isAARCH64()) { // https://github.com/ziglang/zig/issues/14096 return error.SkipZigTest; @@ -132,7 +132,7 @@ test "simple variadic function" { } }; - if (builtin.zig_backend != .stage2_c) { + if (builtin.zig_backend != .zsf_c) { // pre C23 doesn't support varargs without a preceding runtime arg. try std.testing.expectEqual(@as(c_int, 0), S.simple(@as(c_int, 0))); try std.testing.expectEqual(@as(c_int, 1024), S.simple(@as(c_int, 1024))); @@ -145,12 +145,12 @@ test "simple variadic function" { } test "variadic functions" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (builtin.os.tag != .macos and comptime builtin.cpu.arch.isAARCH64()) { // https://github.com/ziglang/zig/issues/14096 return error.SkipZigTest; @@ -190,11 +190,11 @@ test "variadic functions" { } test "copy VaList" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (builtin.os.tag != .macos and comptime builtin.cpu.arch.isAARCH64()) { // https://github.com/ziglang/zig/issues/14096 return error.SkipZigTest; @@ -223,11 +223,11 @@ test "copy VaList" { } test "unused VaList arg" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; if (builtin.os.tag != .macos and comptime builtin.cpu.arch.isAARCH64()) { // https://github.com/ziglang/zig/issues/14096 return error.SkipZigTest; diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig index 0b95caa0d36b..d23639d22984 100644 --- a/test/behavior/vector.zig +++ b/test/behavior/vector.zig @@ -7,12 +7,12 @@ const expect = std.testing.expect; const expectEqual = std.testing.expectEqual; test "implicit cast vector to array - bool" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -26,13 +26,13 @@ test "implicit cast vector to array - bool" { } test "vector wrap operators" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64 and !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -50,12 +50,12 @@ test "vector wrap operators" { } test "vector bin compares with mem.eql" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -74,12 +74,12 @@ test "vector bin compares with mem.eql" { } test "vector int operators" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -96,13 +96,13 @@ test "vector int operators" { } test "vector float operators" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| { const S = struct { @@ -121,11 +121,11 @@ test "vector float operators" { } test "vector bit operators" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -141,10 +141,10 @@ test "vector bit operators" { } test "implicit cast vector to array" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -159,10 +159,10 @@ test "implicit cast vector to array" { } test "array to vector" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -177,12 +177,12 @@ test "array to vector" { } test "array vector coercion - odd sizes" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -214,13 +214,13 @@ test "array vector coercion - odd sizes" { } test "array to vector with element type coercion" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64 and !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .f16c)) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -235,12 +235,12 @@ test "array to vector with element type coercion" { } test "peer type resolution with coercible element types" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -255,14 +255,14 @@ test "peer type resolution with coercible element types" { } test "tuple to vector" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + + if (builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .aarch64) { // Regressed with LLVM 14: // https://github.com/ziglang/zig/issues/12012 return error.SkipZigTest; @@ -285,12 +285,12 @@ test "tuple to vector" { } test "vector casts of sizes not divisible by 8" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -321,13 +321,13 @@ test "vector casts of sizes not divisible by 8" { } test "vector @splat" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_llvm and + if (builtin.zig_backend == .zsf_llvm and builtin.os.tag == .macos) { // LLVM 15 regression: https://github.com/ziglang/zig/issues/12827 @@ -368,10 +368,10 @@ test "vector @splat" { } test "load vector elements via comptime index" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -390,10 +390,10 @@ test "load vector elements via comptime index" { } test "store vector elements via comptime index" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -418,10 +418,10 @@ test "store vector elements via comptime index" { } test "load vector elements via runtime index" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -440,10 +440,10 @@ test "load vector elements via runtime index" { } test "store vector elements via runtime index" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -463,10 +463,10 @@ test "store vector elements via runtime index" { } test "initialize vector which is a struct field" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Vec4Obj = struct { data: @Vector(4, f32), @@ -485,12 +485,12 @@ test "initialize vector which is a struct field" { } test "vector comparison operators" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -528,13 +528,13 @@ test "vector comparison operators" { } test "vector division operators" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_llvm and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_llvm and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void { @@ -612,12 +612,12 @@ test "vector division operators" { } test "vector bitwise not operator" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTestNot(comptime T: type, x: @Vector(4, T)) !void { @@ -644,12 +644,12 @@ test "vector bitwise not operator" { } test "vector shift operators" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTestShift(x: anytype, y: anytype) !void { @@ -738,13 +738,13 @@ test "vector shift operators" { } test "vector reduce operation" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; const S = struct { fn testReduce(comptime op: std.builtin.ReduceOp, x: anytype, expected: anytype) !void { @@ -796,7 +796,7 @@ test "vector reduce operation" { // LLVM 11 ERROR: Cannot select type // https://github.com/ziglang/zig/issues/7138 - if (builtin.zig_backend != .stage2_llvm or builtin.target.cpu.arch != .aarch64) { + if (builtin.zig_backend != .zsf_llvm or builtin.target.cpu.arch != .aarch64) { try testReduce(.Min, [4]i64{ 1234567, -386, 0, 3 }, @as(i64, -386)); try testReduce(.Min, [4]u64{ 99, 9999, 9, 99999 }, @as(u64, 9)); } @@ -814,7 +814,7 @@ test "vector reduce operation" { // LLVM 11 ERROR: Cannot select type // https://github.com/ziglang/zig/issues/7138 - if (builtin.zig_backend != .stage2_llvm or builtin.target.cpu.arch != .aarch64) { + if (builtin.zig_backend != .zsf_llvm or builtin.target.cpu.arch != .aarch64) { try testReduce(.Max, [4]i64{ 1234567, -386, 0, 3 }, @as(i64, 1234567)); try testReduce(.Max, [4]u64{ 99, 9999, 9, 99999 }, @as(u64, 99999)); } @@ -862,7 +862,7 @@ test "vector reduce operation" { // LLVM 11 ERROR: Cannot select type // https://github.com/ziglang/zig/issues/7138 - if (builtin.zig_backend != .stage2_llvm) { + if (builtin.zig_backend != .zsf_llvm) { try testReduce(.Min, [4]f16{ -1.9, 5.1, f16_nan, 100.0 }, @as(f16, -1.9)); try testReduce(.Min, [4]f32{ -1.9, 5.1, f32_nan, 100.0 }, @as(f32, -1.9)); try testReduce(.Min, [4]f64{ -1.9, 5.1, f64_nan, 100.0 }, @as(f64, -1.9)); @@ -883,10 +883,10 @@ test "vector reduce operation" { } test "vector @reduce comptime" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const V = @Vector(4, i32); @@ -900,11 +900,11 @@ test "vector @reduce comptime" { } test "mask parameter of @shuffle is comptime scope" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const __v4hi = @Vector(4, i16); var v4_a = __v4hi{ 0, 0, 0, 0 }; @@ -919,12 +919,12 @@ test "mask parameter of @shuffle is comptime scope" { } test "saturating add" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -951,12 +951,12 @@ test "saturating add" { } test "saturating subtraction" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -974,12 +974,12 @@ test "saturating subtraction" { } test "saturating multiplication" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO: once #9660 has been solved, remove this line if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest; @@ -1001,12 +1001,12 @@ test "saturating multiplication" { } test "saturating shift-left" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1024,12 +1024,12 @@ test "saturating shift-left" { } test "multiplication-assignment operator with an array operand" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1045,12 +1045,12 @@ test "multiplication-assignment operator with an array operand" { } test "@addWithOverflow" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1089,12 +1089,12 @@ test "@addWithOverflow" { } test "@subWithOverflow" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1119,12 +1119,12 @@ test "@subWithOverflow" { } test "@mulWithOverflow" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1140,12 +1140,12 @@ test "@mulWithOverflow" { } test "@shlWithOverflow" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1168,11 +1168,11 @@ test "alignment of vectors" { } test "loading the second vector from a slice of vectors" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; @setRuntimeSafety(false); var small_bases = [2]@Vector(2, u8){ @@ -1185,11 +1185,11 @@ test "loading the second vector from a slice of vectors" { } test "array of vectors is copied" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const Vec3 = @Vector(3, i32); var points = [_]Vec3{ @@ -1208,14 +1208,14 @@ test "array of vectors is copied" { } test "byte vector initialized in inline function" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - - if (comptime builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + + if (comptime builtin.zig_backend == .zsf_llvm and builtin.cpu.arch == .x86_64 and builtin.cpu.features.isEnabled(@intFromEnum(std.Target.x86.Feature.avx512f))) { // TODO https://github.com/ziglang/zig/issues/13279 @@ -1236,10 +1236,10 @@ test "byte vector initialized in inline function" { } test "zero divisor" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const zeros = @Vector(2, f32){ 0.0, 0.0 }; const ones = @Vector(2, f32){ 1.0, 1.0 }; @@ -1256,11 +1256,11 @@ test "zero divisor" { } test "zero multiplicand" { - if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const zeros = @Vector(2, u32){ 0.0, 0.0 }; var ones = @Vector(2, u32){ 1.0, 1.0 }; @@ -1279,12 +1279,12 @@ test "zero multiplicand" { } test "@intCast to u0" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var zeros = @Vector(2, u32){ 0, 0 }; const casted = @as(@Vector(2, u0), @intCast(zeros)); @@ -1303,12 +1303,12 @@ test "modRem with zero divisor" { } test "array operands to shuffle are coerced to vectors" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const mask = [5]i32{ -1, 0, 1, 2, 3 }; @@ -1318,12 +1318,12 @@ test "array operands to shuffle are coerced to vectors" { } test "load packed vector element" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - 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 == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO var x: @Vector(2, u15) = .{ 1, 4 }; try expect((&x[0]).* == 1); @@ -1331,13 +1331,13 @@ test "load packed vector element" { } test "store packed vector element" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - 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_c) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO var v = @Vector(4, u1){ 1, 1, 1, 1 }; try expectEqual(@Vector(4, u1){ 1, 1, 1, 1 }, v); @@ -1347,12 +1347,12 @@ test "store packed vector element" { } test "store to vector in slice" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var v = [_]@Vector(3, f32){ .{ 1, 1, 1 }, @@ -1365,15 +1365,15 @@ test "store to vector in slice" { } test "store vector with memset" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO - - if (builtin.zig_backend == .stage2_llvm) { + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_c) return error.SkipZigTest; // TODO + + if (builtin.zig_backend == .zsf_llvm) { switch (builtin.target.cpu.arch) { .wasm32, .mips, @@ -1414,9 +1414,9 @@ test "store vector with memset" { } test "addition of vectors represented as strings" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const V = @Vector(3, u8); const foo: V = "foo".*; @@ -1425,12 +1425,12 @@ test "addition of vectors represented as strings" { } test "compare vectors with different element types" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO var a: @Vector(2, u8) = .{ 1, 2 }; var b: @Vector(2, u9) = .{ 3, 0 }; @@ -1438,12 +1438,12 @@ test "compare vectors with different element types" { } test "vector pointer is indexable" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const V = @Vector(2, u32); @@ -1464,12 +1464,12 @@ test "vector pointer is indexable" { } test "boolean vector with 2 or more booleans" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO // TODO: try removing this after : if (!(builtin.os.tag == .linux and builtin.cpu.arch == .x86_64)) return; @@ -1482,12 +1482,12 @@ test "boolean vector with 2 or more booleans" { } test "bitcast to vector with different child type" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { diff --git a/test/behavior/void.zig b/test/behavior/void.zig index b726dbe00458..4edf30d6a341 100644 --- a/test/behavior/void.zig +++ b/test/behavior/void.zig @@ -19,8 +19,8 @@ test "compare void with void compile time known" { } test "iterate over a void slice" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var j: usize = 0; for (times(10), 0..) |_, i| { @@ -34,10 +34,10 @@ fn times(n: usize) []const void { } test "void optional" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: ?void = {}; try expect(x != null); diff --git a/test/behavior/while.zig b/test/behavior/while.zig index e52b39474694..7e13ebded592 100644 --- a/test/behavior/while.zig +++ b/test/behavior/while.zig @@ -4,7 +4,7 @@ const expect = std.testing.expect; const assert = std.debug.assert; test "while loop" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO var i: i32 = 0; while (i < 4) { @@ -23,7 +23,7 @@ fn whileLoop2() i32 { } test "static eval while" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO try expect(static_eval_while_number == 1); } @@ -50,7 +50,7 @@ test "while with continue expression" { } test "while with else" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var sum: i32 = 0; var i: i32 = 0; @@ -79,7 +79,7 @@ fn getNumberOrNull() ?i32 { } test "continue outer while loop" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; testContinueOuter(); comptime testContinueOuter(); @@ -108,8 +108,8 @@ fn testBreakOuter() void { } test "while copies its payload" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -126,8 +126,8 @@ test "while copies its payload" { } test "continue and break" { - if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try runContinueAndBreakTest(); try expect(continue_and_break_counter == 8); @@ -147,9 +147,9 @@ fn runContinueAndBreakTest() !void { } test "while with optional as condition" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; numbers_left = 10; var sum: i32 = 0; @@ -160,9 +160,9 @@ test "while with optional as condition" { } test "while with optional as condition with else" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; numbers_left = 10; var sum: i32 = 0; @@ -178,8 +178,8 @@ test "while with optional as condition with else" { } test "while with error union condition" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; numbers_left = 10; var sum: i32 = 0; @@ -209,9 +209,9 @@ test "while on bool with else result follow break prong" { } test "while on optional with else result follow else prong" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const result = while (returnNull()) |value| { break value; @@ -220,10 +220,10 @@ test "while on optional with else result follow else prong" { } test "while on optional with else result follow break prong" { - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const result = while (returnOptional(10)) |value| { break value; @@ -251,7 +251,7 @@ fn returnTrue() bool { } test "return with implicit cast from while loop" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; returnWithImplicitCastFromWhileLoopTest() catch unreachable; } @@ -262,8 +262,8 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void { } test "while on error union with else result follow else prong" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const result = while (returnError()) |value| { break value; @@ -272,8 +272,8 @@ test "while on error union with else result follow else prong" { } test "while on error union with else result follow break prong" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const result = while (returnSuccess(10)) |value| { break value; @@ -297,9 +297,9 @@ test "while bool 2 break statements and an else" { } test "while optional 2 break statements and an else" { - 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_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO const S = struct { fn entry(opt_t: ?bool, f: bool) !void { @@ -316,10 +316,10 @@ test "while optional 2 break statements and an else" { } test "while error 2 break statements and an else" { - 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_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const S = struct { fn entry(opt_t: anyerror!bool, f: bool) !void { @@ -345,7 +345,7 @@ test "continue inline while loop" { } test "else continue outer while" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var i: usize = 0; while (true) { @@ -357,9 +357,9 @@ test "else continue outer while" { } test "try terminating an infinite loop" { - 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_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; // Test coverage for https://github.com/ziglang/zig/issues/13546 const Foo = struct { diff --git a/test/behavior/widening.zig b/test/behavior/widening.zig index d3efa739409f..91c644c3dead 100644 --- a/test/behavior/widening.zig +++ b/test/behavior/widening.zig @@ -5,10 +5,10 @@ const builtin = @import("builtin"); const has_f80_rt = @import("builtin").cpu.arch == .x86_64; test "integer widening" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: u8 = 250; var b: u16 = a; @@ -23,16 +23,16 @@ fn zero() u0 { return 0; } test "integer widening u0 to u8" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; const a: u8 = zero(); try expect(a == 0); } test "implicit unsigned integer to signed integer" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: u8 = 250; var b: i16 = a; @@ -40,12 +40,12 @@ test "implicit unsigned integer to signed integer" { } test "float widening" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var a: f16 = 12.34; var b: f32 = a; @@ -61,12 +61,12 @@ test "float widening" { } test "float widening f16 to f128" { - 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_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_wasm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_x86_64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; var x: f16 = 12.34; var y: f128 = x; @@ -74,10 +74,10 @@ test "float widening f16 to f128" { } test "cast small unsigned to larger signed" { - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + if (builtin.zig_backend == .zsf_aarch64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_arm) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_sparc64) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .zsf_spirv64) return error.SkipZigTest; try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200)); try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999)); diff --git a/test/cases/safety/@asyncCall with too small a frame.zig b/test/cases/safety/@asyncCall with too small a frame.zig index 1a315930584c..6dc5cc3c11ee 100644 --- a/test/cases/safety/@asyncCall with too small a frame.zig +++ b/test/cases/safety/@asyncCall with too small a frame.zig @@ -7,10 +7,6 @@ pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usi std.process.exit(0); } pub fn main() !void { - if (builtin.zig_backend == .stage1 and builtin.os.tag == .wasi) { - // TODO file a bug for this failure - std.process.exit(0); // skip the test - } var bytes: [1]u8 align(16) = undefined; var ptr = other; var frame = @asyncCall(&bytes, {}, ptr, .{});