Commit 2e6e39a700
Changed files (92)
lib
compiler_rt
std
atomic
Build
compress
lzma
crypto
Certificate
pcurves
fs
hash
math
net
os
src
arch
test
lib/compiler_rt/addf3_test.zig
@@ -4,6 +4,7 @@
// https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/test/builtins/Unit/subtf3_test.c
const std = @import("std");
+const builtin = @import("builtin");
const math = std.math;
const qnan128: f128 = @bitCast(@as(u128, 0x7fff800000000000) << 64);
@@ -34,6 +35,8 @@ fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
}
test "addtf3" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
// NaN + any = NaN
@@ -103,6 +106,8 @@ fn test__addxf3(a: f80, b: f80, expected: u80) !void {
}
test "addxf3" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// NaN + any = NaN
try test__addxf3(qnan80, 0x1.23456789abcdefp+5, @as(u80, @bitCast(qnan80)));
try test__addxf3(@as(f80, @bitCast(@as(u80, 0x7fff_8000_8000_3000_0000))), 0x1.23456789abcdefp+5, @as(u80, @bitCast(qnan80)));
lib/compiler_rt/addoti4_test.zig
@@ -23,6 +23,8 @@ fn simple_addoti4(a: i128, b: i128, overflow: *c_int) i128 {
}
test "addoti4" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const min: i128 = math.minInt(i128);
const max: i128 = math.maxInt(i128);
var i: i128 = 1;
lib/compiler_rt/comparef.zig
@@ -98,6 +98,8 @@ pub inline fn cmp_f80(comptime RT: type, a: f80, b: f80) RT {
}
test "cmp_f80" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
inline for (.{ LE, GE }) |RT| {
try std.testing.expect(cmp_f80(RT, 1.0, 1.0) == RT.Equal);
try std.testing.expect(cmp_f80(RT, 0.0, -0.0) == RT.Equal);
lib/compiler_rt/cos.zig
@@ -1,6 +1,4 @@
const std = @import("std");
-const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
const math = std.math;
const expect = std.testing.expect;
const common = @import("common.zig");
@@ -136,6 +134,8 @@ pub fn cosl(x: c_longdouble) callconv(.C) c_longdouble {
}
test "cos32" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const epsilon = 0.00001;
try expect(math.approxEqAbs(f32, cosf(0.0), 1.0, epsilon));
lib/compiler_rt/divxf3_test.zig
@@ -39,6 +39,8 @@ fn test__divxf3(a: f80, b: f80) !void {
}
test "divxf3" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// NaN / any = NaN
try expect__divxf3_result(math.nan(f80), 0x1.23456789abcdefp+5, 0x7fffC000000000000000);
// inf / any(except inf and nan) = inf
lib/compiler_rt/int.zig
@@ -42,6 +42,8 @@ pub fn __divmodti4(a: i128, b: i128, rem: *i128) callconv(.C) i128 {
}
test "test_divmodti4" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const cases = [_][4]i128{
[_]i128{ 0, 1, 0, 0 },
[_]i128{ 0, -1, 0, 0 },
lib/compiler_rt/int_from_float_test.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const testing = std.testing;
const math = std.math;
@@ -40,6 +41,8 @@ fn test__fixunssfsi(a: f32, expected: u32) !void {
}
test "fixsfsi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixsfsi(-math.floatMax(f32), math.minInt(i32));
try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
@@ -103,6 +106,8 @@ test "fixsfsi" {
}
test "fixunssfsi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixunssfsi(0.0, 0);
try test__fixunssfsi(0.5, 0);
@@ -142,6 +147,8 @@ fn test__fixunssfdi(a: f32, expected: u64) !void {
}
test "fixsfdi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixsfdi(-math.floatMax(f32), math.minInt(i64));
try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
@@ -197,6 +204,8 @@ test "fixsfdi" {
}
test "fixunssfdi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixunssfdi(0.0, 0);
try test__fixunssfdi(0.5, 0);
@@ -235,6 +244,8 @@ fn test__fixunssfti(a: f32, expected: u128) !void {
}
test "fixsfti" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixsfti(-math.floatMax(f32), math.minInt(i128));
try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
@@ -306,6 +317,8 @@ test "fixsfti" {
}
test "fixunssfti" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixunssfti(0.0, 0);
try test__fixunssfti(0.5, 0);
@@ -352,6 +365,8 @@ fn test__fixunsdfsi(a: f64, expected: u32) !void {
}
test "fixdfsi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixdfsi(-math.floatMax(f64), math.minInt(i32));
try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
@@ -413,6 +428,8 @@ test "fixdfsi" {
}
test "fixunsdfsi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixunsdfsi(0.0, 0);
try test__fixunsdfsi(0.5, 0);
@@ -455,6 +472,8 @@ fn test__fixunsdfdi(a: f64, expected: u64) !void {
}
test "fixdfdi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixdfdi(-math.floatMax(f64), math.minInt(i64));
try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
@@ -508,6 +527,8 @@ test "fixdfdi" {
}
test "fixunsdfdi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixunsdfdi(0.0, 0);
try test__fixunsdfdi(0.5, 0);
try test__fixunsdfdi(0.99, 0);
@@ -550,6 +571,8 @@ fn test__fixunsdfti(a: f64, expected: u128) !void {
}
test "fixdfti" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixdfti(-math.floatMax(f64), math.minInt(i128));
try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
@@ -603,6 +626,8 @@ test "fixdfti" {
}
test "fixunsdfti" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixunsdfti(0.0, 0);
try test__fixunsdfti(0.5, 0);
@@ -652,6 +677,8 @@ fn test__fixunstfsi(a: f128, expected: u32) !void {
}
test "fixtfsi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixtfsi(-math.floatMax(f128), math.minInt(i32));
try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
@@ -715,6 +742,8 @@ test "fixtfsi" {
}
test "fixunstfsi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixunstfsi(math.inf(f128), 0xffffffff);
try test__fixunstfsi(0, 0x0);
try test__fixunstfsi(0x1.23456789abcdefp+5, 0x24);
@@ -738,6 +767,8 @@ fn test__fixunstfdi(a: f128, expected: u64) !void {
}
test "fixtfdi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixtfdi(-math.floatMax(f128), math.minInt(i64));
try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
@@ -801,6 +832,8 @@ test "fixtfdi" {
}
test "fixunstfdi" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixunstfdi(0.0, 0);
try test__fixunstfdi(0.5, 0);
@@ -853,6 +886,8 @@ fn test__fixunstfti(a: f128, expected: u128) !void {
}
test "fixtfti" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixtfti(-math.floatMax(f128), math.minInt(i128));
try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
@@ -934,6 +969,8 @@ fn test__fixunshfti(a: f16, expected: u128) !void {
}
test "fixunshfti for f16" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try test__fixunshfti(math.inf(f16), math.maxInt(u128));
try test__fixunshfti(math.floatMax(f16), 65504);
}
lib/compiler_rt/negti2_test.zig
@@ -6,7 +6,9 @@ fn test__negti2(a: i128, expected: i128) !void {
try testing.expectEqual(expected, result);
}
-test "negdi2" {
+test "negti2" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// TODO ensuring that math.minInt(i128); returns error
try test__negti2(-3, 3);
lib/compiler_rt/powiXf2_test.zig
@@ -3,8 +3,10 @@
// powihf2 adapted from powisf2 tests
const powiXf2 = @import("powiXf2.zig");
-const testing = @import("std").testing;
-const math = @import("std").math;
+const std = @import("std");
+const builtin = @import("builtin");
+const testing = std.testing;
+const math = std.math;
fn test__powihf2(a: f16, b: i32, expected: f16) !void {
var result = powiXf2.__powihf2(a, b);
@@ -351,6 +353,8 @@ test "powidf2" {
}
test "powitf2" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const inf_f128 = math.inf(f128);
try test__powitf2(0, 0, 1);
try test__powitf2(1, 0, 1);
@@ -456,6 +460,8 @@ test "powitf2" {
}
test "powixf2" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const inf_f80 = math.inf(f80);
try test__powixf2(0, 0, 1);
try test__powixf2(1, 0, 1);
lib/compiler_rt/sin.zig
@@ -140,6 +140,8 @@ pub fn sinl(x: c_longdouble) callconv(.C) c_longdouble {
}
test "sin32" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const epsilon = 0.00001;
try expect(math.approxEqAbs(f32, sinf(0.0), 0.0, epsilon));
lib/compiler_rt/suboti4_test.zig
@@ -27,6 +27,8 @@ pub fn simple_suboti4(a: i128, b: i128, overflow: *c_int) i128 {
}
test "suboti3" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const min: i128 = math.minInt(i128);
const max: i128 = math.maxInt(i128);
var i: i128 = 1;
lib/compiler_rt/tan.zig
@@ -131,6 +131,8 @@ test "tan" {
}
test "tan32" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const epsilon = 0.00001;
try expect(math.approxEqAbs(f32, tanf(0.0), 0.0, epsilon));
@@ -142,6 +144,8 @@ test "tan32" {
}
test "tan64" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const epsilon = 0.000001;
try expect(math.approxEqAbs(f64, tan(0.0), 0.0, epsilon));
lib/compiler_rt/udivmodei4.zig
@@ -129,7 +129,10 @@ 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
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
const RndGen = std.rand.DefaultPrng;
var rnd = RndGen.init(42);
lib/std/atomic/Atomic.zig
@@ -374,6 +374,8 @@ const atomic_rmw_orderings = [_]Ordering{
};
test "Atomic.swap" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
inline for (atomic_rmw_orderings) |ordering| {
var x = Atomic(usize).init(5);
try testing.expectEqual(x.swap(10, ordering), 5);
lib/std/Build/Step/Options.zig
@@ -296,6 +296,8 @@ const Arg = struct {
test Options {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
lib/std/Build/Cache.zig
@@ -1007,6 +1007,8 @@ test "cache file and then recall it" {
return error.SkipZigTest;
}
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = testing.tmpDir(.{});
defer tmp.cleanup();
@@ -1072,6 +1074,9 @@ test "check that changing a file makes cache fail" {
// https://github.com/ziglang/zig/issues/5437
return error.SkipZigTest;
}
+
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = testing.tmpDir(.{});
defer tmp.cleanup();
@@ -1146,6 +1151,8 @@ test "no file inputs" {
return error.SkipZigTest;
}
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = testing.tmpDir(.{});
defer tmp.cleanup();
@@ -1193,6 +1200,9 @@ test "Manifest with files added after initial hash work" {
// https://github.com/ziglang/zig/issues/5437
return error.SkipZigTest;
}
+
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = testing.tmpDir(.{});
defer tmp.cleanup();
lib/std/compress/lzma/test.zig
@@ -1,4 +1,5 @@
const std = @import("../../std.zig");
+const builtin = @import("builtin");
const lzma = @import("../lzma.zig");
fn testDecompress(compressed: []const u8) ![]u8 {
@@ -22,6 +23,8 @@ fn testDecompressError(expected: anyerror, compressed: []const u8) !void {
}
test "LZMA: decompress empty world" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDecompressEqual(
"",
&[_]u8{
@@ -32,6 +35,8 @@ test "LZMA: decompress empty world" {
}
test "LZMA: decompress hello world" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDecompressEqual(
"Hello world\n",
&[_]u8{
@@ -43,6 +48,8 @@ test "LZMA: decompress hello world" {
}
test "LZMA: decompress huge dict" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDecompressEqual(
"Hello world\n",
&[_]u8{
@@ -54,6 +61,8 @@ test "LZMA: decompress huge dict" {
}
test "LZMA: unknown size with end of payload marker" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDecompressEqual(
"Hello\nWorld!\n",
@embedFile("testdata/good-unknown_size-with_eopm.lzma"),
@@ -61,6 +70,8 @@ test "LZMA: unknown size with end of payload marker" {
}
test "LZMA: known size without end of payload marker" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDecompressEqual(
"Hello\nWorld!\n",
@embedFile("testdata/good-known_size-without_eopm.lzma"),
@@ -68,6 +79,8 @@ test "LZMA: known size without end of payload marker" {
}
test "LZMA: known size with end of payload marker" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDecompressEqual(
"Hello\nWorld!\n",
@embedFile("testdata/good-known_size-with_eopm.lzma"),
@@ -75,6 +88,8 @@ test "LZMA: known size with end of payload marker" {
}
test "LZMA: too big uncompressed size in header" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDecompressError(
error.CorruptInput,
@embedFile("testdata/bad-too_big_size-with_eopm.lzma"),
@@ -82,6 +97,8 @@ test "LZMA: too big uncompressed size in header" {
}
test "LZMA: too small uncompressed size in header" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDecompressError(
error.CorruptInput,
@embedFile("testdata/bad-too_small_size-without_eopm-3.lzma"),
lib/std/crypto/25519/curve25519.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const crypto = std.crypto;
const IdentityElementError = crypto.errors.IdentityElementError;
@@ -111,6 +112,8 @@ pub const Curve25519 = struct {
};
test "curve25519" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var s = [32]u8{ 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8 };
const p = try Curve25519.basePoint.clampedMul(s);
try p.rejectIdentity();
@@ -125,6 +128,8 @@ test "curve25519" {
}
test "curve25519 small order check" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var s: [32]u8 = [_]u8{1} ++ [_]u8{0} ** 31;
const small_order_ss: [7][32]u8 = .{
.{
lib/std/crypto/25519/ed25519.zig
@@ -1,5 +1,5 @@
-const builtin = @import("builtin");
const std = @import("std");
+const builtin = @import("builtin");
const crypto = std.crypto;
const debug = std.debug;
const fmt = std.fmt;
@@ -484,6 +484,8 @@ pub const Ed25519 = struct {
};
test "ed25519 key pair creation" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var seed: [32]u8 = undefined;
_ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
const key_pair = try Ed25519.KeyPair.create(seed);
@@ -493,6 +495,8 @@ test "ed25519 key pair creation" {
}
test "ed25519 signature" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var seed: [32]u8 = undefined;
_ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
const key_pair = try Ed25519.KeyPair.create(seed);
@@ -505,6 +509,8 @@ test "ed25519 signature" {
}
test "ed25519 batch verification" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var i: usize = 0;
while (i < 100) : (i += 1) {
const key_pair = try Ed25519.KeyPair.create(null);
@@ -534,6 +540,8 @@ test "ed25519 batch verification" {
}
test "ed25519 test vectors" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const Vec = struct {
msg_hex: *const [64:0]u8,
public_key_hex: *const [64:0]u8,
@@ -636,6 +644,8 @@ test "ed25519 test vectors" {
}
test "ed25519 with blind keys" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const BlindKeyPair = Ed25519.key_blinding.BlindKeyPair;
// Create a standard Ed25519 key pair
@@ -659,6 +669,8 @@ test "ed25519 with blind keys" {
}
test "ed25519 signatures with streaming" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const kp = try Ed25519.KeyPair.create(null);
var signer = try kp.signer(null);
@@ -675,6 +687,8 @@ test "ed25519 signatures with streaming" {
}
test "ed25519 key pair from secret key" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const kp = try Ed25519.KeyPair.create(null);
const kp2 = try Ed25519.KeyPair.fromSecretKey(kp.secret_key);
try std.testing.expectEqualSlices(u8, &kp.secret_key.toBytes(), &kp2.secret_key.toBytes());
lib/std/crypto/25519/edwards25519.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const crypto = std.crypto;
const debug = std.debug;
const fmt = std.fmt;
@@ -494,6 +495,8 @@ pub const Edwards25519 = struct {
const htest = @import("../test.zig");
test "edwards25519 packing/unpacking" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const s = [_]u8{170} ++ [_]u8{0} ** 31;
var b = Edwards25519.basePoint;
const pk = try b.mul(s);
@@ -530,6 +533,8 @@ test "edwards25519 packing/unpacking" {
}
test "edwards25519 point addition/subtraction" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var s1: [32]u8 = undefined;
var s2: [32]u8 = undefined;
crypto.random.bytes(&s1);
@@ -544,6 +549,8 @@ test "edwards25519 point addition/subtraction" {
}
test "edwards25519 uniform-to-point" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var r = [32]u8{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 };
var p = Edwards25519.fromUniform(r);
try htest.assertEqual("0691eee3cf70a0056df6bfa03120635636581b5c4ea571dfc680f78c7e0b4137", p.toBytes()[0..]);
@@ -555,6 +562,8 @@ test "edwards25519 uniform-to-point" {
// Test vectors from draft-irtf-cfrg-hash-to-curve-12
test "edwards25519 hash-to-curve operation" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var p = Edwards25519.fromString(true, "QUUX-V01-CS02-with-edwards25519_XMD:SHA-512_ELL2_RO_", "abc");
try htest.assertEqual("31558a26887f23fb8218f143e69d5f0af2e7831130bd5b432ef23883b895839a", p.toBytes()[0..]);
@@ -563,6 +572,8 @@ test "edwards25519 hash-to-curve operation" {
}
test "edwards25519 implicit reduction of invalid scalars" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const s = [_]u8{0} ** 31 ++ [_]u8{255};
const p1 = try Edwards25519.basePoint.mulPublic(s);
const p2 = try Edwards25519.basePoint.mul(s);
lib/std/crypto/25519/ristretto255.zig
@@ -168,6 +168,8 @@ pub const Ristretto255 = struct {
};
test "ristretto255" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const p = Ristretto255.basePoint;
var buf: [256]u8 = undefined;
try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&p.toBytes())}), "E2F2AE0A6ABC4E71A884A961C500515F58E30B6AA582DD8DB6A65945E08D2D76");
lib/std/crypto/25519/x25519.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const crypto = std.crypto;
const mem = std.mem;
const fmt = std.fmt;
@@ -82,6 +83,8 @@ pub const X25519 = struct {
const htest = @import("../test.zig");
test "x25519 public key calculation from secret key" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var sk: [32]u8 = undefined;
var pk_expected: [32]u8 = undefined;
_ = try fmt.hexToBytes(sk[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
@@ -91,6 +94,8 @@ test "x25519 public key calculation from secret key" {
}
test "x25519 rfc7748 vector1" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const secret_key = [32]u8{ 0xa5, 0x46, 0xe3, 0x6b, 0xf0, 0x52, 0x7c, 0x9d, 0x3b, 0x16, 0x15, 0x4b, 0x82, 0x46, 0x5e, 0xdd, 0x62, 0x14, 0x4c, 0x0a, 0xc1, 0xfc, 0x5a, 0x18, 0x50, 0x6a, 0x22, 0x44, 0xba, 0x44, 0x9a, 0xc4 };
const public_key = [32]u8{ 0xe6, 0xdb, 0x68, 0x67, 0x58, 0x30, 0x30, 0xdb, 0x35, 0x94, 0xc1, 0xa4, 0x24, 0xb1, 0x5f, 0x7c, 0x72, 0x66, 0x24, 0xec, 0x26, 0xb3, 0x35, 0x3b, 0x10, 0xa9, 0x03, 0xa6, 0xd0, 0xab, 0x1c, 0x4c };
@@ -101,6 +106,8 @@ test "x25519 rfc7748 vector1" {
}
test "x25519 rfc7748 vector2" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const secret_key = [32]u8{ 0x4b, 0x66, 0xe9, 0xd4, 0xd1, 0xb4, 0x67, 0x3c, 0x5a, 0xd2, 0x26, 0x91, 0x95, 0x7d, 0x6a, 0xf5, 0xc1, 0x1b, 0x64, 0x21, 0xe0, 0xea, 0x01, 0xd4, 0x2c, 0xa4, 0x16, 0x9e, 0x79, 0x18, 0xba, 0x0d };
const public_key = [32]u8{ 0xe5, 0x21, 0x0f, 0x12, 0x78, 0x68, 0x11, 0xd3, 0xf4, 0xb7, 0x95, 0x9d, 0x05, 0x38, 0xae, 0x2c, 0x31, 0xdb, 0xe7, 0x10, 0x6f, 0xc0, 0x3c, 0x3e, 0xfc, 0x4c, 0xd5, 0x49, 0xc7, 0x15, 0xa4, 0x93 };
@@ -111,6 +118,8 @@ test "x25519 rfc7748 vector2" {
}
test "x25519 rfc7748 one iteration" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const initial_value = [32]u8{ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
const expected_output = [32]u8{ 0x42, 0x2c, 0x8e, 0x7a, 0x62, 0x27, 0xd7, 0xbc, 0xa1, 0x35, 0x0b, 0x3e, 0x2b, 0xb7, 0x27, 0x9f, 0x78, 0x97, 0xb8, 0x7b, 0xb6, 0x85, 0x4b, 0x78, 0x3c, 0x60, 0xe8, 0x03, 0x11, 0xae, 0x30, 0x79 };
@@ -128,6 +137,8 @@ test "x25519 rfc7748 one iteration" {
}
test "x25519 rfc7748 1,000 iterations" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// These iteration tests are slow so we always skip them. Results have been verified.
if (true) {
return error.SkipZigTest;
@@ -150,6 +161,8 @@ test "x25519 rfc7748 1,000 iterations" {
}
test "x25519 rfc7748 1,000,000 iterations" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (true) {
return error.SkipZigTest;
}
@@ -171,6 +184,8 @@ test "x25519 rfc7748 1,000,000 iterations" {
}
test "edwards25519 -> curve25519 map" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const ed_kp = try crypto.sign.Ed25519.KeyPair.create([_]u8{0x42} ** 32);
const mont_kp = try X25519.KeyPair.fromEd25519(ed_kp);
try htest.assertEqual("90e7595fc89e52fdfddce9c6a43d74dbf6047025ee0462d2d172e8b6a2841d6e", &mont_kp.secret_key);
lib/std/crypto/Certificate/Bundle.zig
@@ -318,6 +318,8 @@ const MapContext = struct {
test "scan for OS-provided certificates" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var bundle: Bundle = .{};
defer bundle.deinit(std.testing.allocator);
lib/std/crypto/pcurves/p256.zig
@@ -478,5 +478,7 @@ pub const AffineCoordinates = struct {
};
test {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
_ = @import("tests/p256.zig");
}
lib/std/crypto/aegis.zig
@@ -17,6 +17,7 @@
//! https://datatracker.ietf.org/doc/draft-irtf-cfrg-aegis-aead/
const std = @import("std");
+const builtin = @import("builtin");
const crypto = std.crypto;
const mem = std.mem;
const assert = std.debug.assert;
@@ -513,6 +514,8 @@ const htest = @import("test.zig");
const testing = std.testing;
test "Aegis128L test vector 1" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key: [Aegis128L.key_length]u8 = [_]u8{ 0x10, 0x01 } ++ [_]u8{0x00} ** 14;
const nonce: [Aegis128L.nonce_length]u8 = [_]u8{ 0x10, 0x00, 0x02 } ++ [_]u8{0x00} ** 13;
const ad = [8]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
@@ -536,6 +539,8 @@ test "Aegis128L test vector 1" {
}
test "Aegis128L test vector 2" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key: [Aegis128L.key_length]u8 = [_]u8{0x00} ** 16;
const nonce: [Aegis128L.nonce_length]u8 = [_]u8{0x00} ** 16;
const ad = [_]u8{};
@@ -553,6 +558,8 @@ test "Aegis128L test vector 2" {
}
test "Aegis128L test vector 3" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key: [Aegis128L.key_length]u8 = [_]u8{0x00} ** 16;
const nonce: [Aegis128L.nonce_length]u8 = [_]u8{0x00} ** 16;
const ad = [_]u8{};
@@ -569,6 +576,8 @@ test "Aegis128L test vector 3" {
}
test "Aegis256 test vector 1" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key: [Aegis256.key_length]u8 = [_]u8{ 0x10, 0x01 } ++ [_]u8{0x00} ** 30;
const nonce: [Aegis256.nonce_length]u8 = [_]u8{ 0x10, 0x00, 0x02 } ++ [_]u8{0x00} ** 29;
const ad = [8]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
@@ -592,6 +601,8 @@ test "Aegis256 test vector 1" {
}
test "Aegis256 test vector 2" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key: [Aegis256.key_length]u8 = [_]u8{0x00} ** 32;
const nonce: [Aegis256.nonce_length]u8 = [_]u8{0x00} ** 32;
const ad = [_]u8{};
@@ -609,6 +620,8 @@ test "Aegis256 test vector 2" {
}
test "Aegis256 test vector 3" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key: [Aegis256.key_length]u8 = [_]u8{0x00} ** 32;
const nonce: [Aegis256.nonce_length]u8 = [_]u8{0x00} ** 32;
const ad = [_]u8{};
@@ -625,6 +638,8 @@ test "Aegis256 test vector 3" {
}
test "Aegis MAC" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{0x00} ** Aegis128LMac.key_length;
var msg: [64]u8 = undefined;
for (&msg, 0..) |*m, i| {
lib/std/crypto/aes.zig
@@ -28,6 +28,8 @@ pub const Aes128 = impl.Aes128;
pub const Aes256 = impl.Aes256;
test "ctr" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// NIST SP 800-38A pp 55-58
const ctr = @import("modes.zig").ctr;
@@ -53,6 +55,8 @@ test "ctr" {
}
test "encrypt" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// Appendix B
{
const key = [_]u8{ 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c };
@@ -82,6 +86,8 @@ test "encrypt" {
}
test "decrypt" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// Appendix B
{
const key = [_]u8{ 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c };
@@ -111,6 +117,8 @@ test "decrypt" {
}
test "expand 128-bit key" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{ 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c };
const exp_enc = [_]*const [32:0]u8{
"2b7e151628aed2a6abf7158809cf4f3c", "a0fafe1788542cb123a339392a6c7605", "f2c295f27a96b9435935807a7359f67f", "3d80477d4716fe3e1e237e446d7a883b", "ef44a541a8525b7fb671253bdb0bad00", "d4d1c6f87c839d87caf2b8bc11f915bc", "6d88a37a110b3efddbf98641ca0093fd", "4e54f70e5f5fc9f384a64fb24ea6dc4f", "ead27321b58dbad2312bf5607f8d292f", "ac7766f319fadc2128d12941575c006e", "d014f9a8c9ee2589e13f0cc8b6630ca6",
@@ -133,6 +141,8 @@ test "expand 128-bit key" {
}
test "expand 256-bit key" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{
0x60, 0x3d, 0xeb, 0x10,
0x15, 0xca, 0x71, 0xbe,
lib/std/crypto/aes_gcm.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const assert = std.debug.assert;
const crypto = std.crypto;
const debug = std.debug;
@@ -112,6 +113,8 @@ const htest = @import("test.zig");
const testing = std.testing;
test "Aes256Gcm - Empty message and no associated data" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key: [Aes256Gcm.key_length]u8 = [_]u8{0x69} ** Aes256Gcm.key_length;
const nonce: [Aes256Gcm.nonce_length]u8 = [_]u8{0x42} ** Aes256Gcm.nonce_length;
const ad = "";
@@ -124,6 +127,8 @@ test "Aes256Gcm - Empty message and no associated data" {
}
test "Aes256Gcm - Associated data only" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key: [Aes256Gcm.key_length]u8 = [_]u8{0x69} ** Aes256Gcm.key_length;
const nonce: [Aes256Gcm.nonce_length]u8 = [_]u8{0x42} ** Aes256Gcm.nonce_length;
const m = "";
@@ -136,6 +141,8 @@ test "Aes256Gcm - Associated data only" {
}
test "Aes256Gcm - Message only" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key: [Aes256Gcm.key_length]u8 = [_]u8{0x69} ** Aes256Gcm.key_length;
const nonce: [Aes256Gcm.nonce_length]u8 = [_]u8{0x42} ** Aes256Gcm.nonce_length;
const m = "Test with message only";
@@ -153,6 +160,8 @@ test "Aes256Gcm - Message only" {
}
test "Aes256Gcm - Message and associated data" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key: [Aes256Gcm.key_length]u8 = [_]u8{0x69} ** Aes256Gcm.key_length;
const nonce: [Aes256Gcm.nonce_length]u8 = [_]u8{0x42} ** Aes256Gcm.nonce_length;
const m = "Test with message";
lib/std/crypto/aes_ocb.zig
@@ -261,7 +261,10 @@ 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;
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
var k: [Aes128Ocb.key_length]u8 = undefined;
var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
@@ -280,7 +283,10 @@ test "AesOcb test vector 1" {
}
test "AesOcb test vector 2" {
- if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
var k: [Aes128Ocb.key_length]u8 = undefined;
var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
@@ -301,7 +307,10 @@ test "AesOcb test vector 2" {
}
test "AesOcb test vector 3" {
- if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
var k: [Aes128Ocb.key_length]u8 = undefined;
var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
@@ -325,7 +334,10 @@ test "AesOcb test vector 3" {
}
test "AesOcb test vector 4" {
- if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
var k: [Aes128Ocb.key_length]u8 = undefined;
var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
lib/std/crypto/argon2.zig
@@ -622,6 +622,8 @@ pub fn strVerify(
}
test "argon2d" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const password = [_]u8{0x01} ** 32;
const salt = [_]u8{0x02} ** 16;
const secret = [_]u8{0x03} ** 8;
@@ -647,6 +649,8 @@ test "argon2d" {
}
test "argon2i" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const password = [_]u8{0x01} ** 32;
const salt = [_]u8{0x02} ** 16;
const secret = [_]u8{0x03} ** 8;
@@ -672,6 +676,8 @@ test "argon2i" {
}
test "argon2id" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const password = [_]u8{0x01} ** 32;
const salt = [_]u8{0x02} ** 16;
const secret = [_]u8{0x03} ** 8;
@@ -697,6 +703,8 @@ test "argon2id" {
}
test "kdf" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const password = "password";
const salt = "somesalt";
@@ -896,6 +904,8 @@ test "kdf" {
}
test "phc format hasher" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const allocator = std.testing.allocator;
const password = "testpass";
@@ -911,6 +921,8 @@ test "phc format hasher" {
}
test "password hash and password verify" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const allocator = std.testing.allocator;
const password = "testpass";
@@ -924,6 +936,8 @@ test "password hash and password verify" {
}
test "kdf derived key length" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const allocator = std.testing.allocator;
const password = "testpass";
lib/std/crypto/bcrypt.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const base64 = std.base64;
const crypto = std.crypto;
const debug = std.debug;
@@ -753,6 +754,8 @@ pub fn strVerify(
}
test "bcrypt codec" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var salt: [salt_length]u8 = undefined;
crypto.random.bytes(&salt);
var salt_str: [salt_str_length]u8 = undefined;
@@ -763,6 +766,8 @@ test "bcrypt codec" {
}
test "bcrypt crypt format" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var hash_options = HashOptions{
.params = .{ .rounds_log = 5 },
.encoding = .crypt,
@@ -803,6 +808,8 @@ test "bcrypt crypt format" {
}
test "bcrypt phc format" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var hash_options = HashOptions{
.params = .{ .rounds_log = 5 },
.encoding = .phc,
lib/std/crypto/blake3.zig
@@ -200,7 +200,7 @@ const CompressGeneric = struct {
}
};
-const compress = if (builtin.cpu.arch == .x86_64)
+const compress = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .stage2_x86_64)
CompressVectorized.compress
else
CompressGeneric.compress;
@@ -682,6 +682,8 @@ fn testBlake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) !void {
}
test "BLAKE3 reference test cases" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var hash_state = Blake3.init(.{});
const hash = &hash_state;
var keyed_hash_state = Blake3.init(.{ .key = reference_test.key.* });
lib/std/crypto/Certificate.zig
@@ -624,6 +624,8 @@ pub fn parseTimeDigits(text: *const [2]u8, min: u8, max: u8) !u8 {
}
test parseTimeDigits {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const expectEqual = std.testing.expectEqual;
try expectEqual(@as(u8, 0), try parseTimeDigits("00", 0, 99));
try expectEqual(@as(u8, 99), try parseTimeDigits("99", 0, 99));
@@ -645,6 +647,8 @@ pub fn parseYear4(text: *const [4]u8) !u16 {
}
test parseYear4 {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const expectEqual = std.testing.expectEqual;
try expectEqual(@as(u16, 0), try parseYear4("0000"));
try expectEqual(@as(u16, 9999), try parseYear4("9999"));
@@ -1119,3 +1123,5 @@ pub const rsa = struct {
return res;
}
};
+
+const builtin = @import("builtin");
lib/std/crypto/chacha20.zig
@@ -499,6 +499,8 @@ fn ChaChaNonVecImpl(comptime rounds_nb: usize) type {
fn ChaChaImpl(comptime rounds_nb: usize) type {
switch (builtin.cpu.arch) {
.x86_64 => {
+ if (builtin.zig_backend == .stage2_x86_64) return ChaChaNonVecImpl(rounds_nb);
+
const has_avx2 = std.Target.x86.featureSetHas(builtin.cpu.features, .avx2);
const has_avx512f = std.Target.x86.featureSetHas(builtin.cpu.features, .avx512f);
if (has_avx512f) return ChaChaVecImpl(rounds_nb, 4);
@@ -757,6 +759,8 @@ fn XChaChaPoly1305(comptime rounds_nb: usize) type {
}
test "chacha20 AEAD API" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const aeads = [_]type{ ChaCha20Poly1305, XChaCha20Poly1305 };
const m = "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.";
const ad = "Additional data";
@@ -778,6 +782,8 @@ test "chacha20 AEAD API" {
// https://tools.ietf.org/html/rfc7539#section-2.4.2
test "crypto.chacha20 test vector sunscreen" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const expected_result = [_]u8{
0x6e, 0x2e, 0x35, 0x9a, 0x25, 0x68, 0xf9, 0x80,
0x41, 0xba, 0x07, 0x28, 0xdd, 0x0d, 0x69, 0x81,
@@ -819,6 +825,8 @@ test "crypto.chacha20 test vector sunscreen" {
// https://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04#section-7
test "crypto.chacha20 test vector 1" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const expected_result = [_]u8{
0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90,
0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28,
@@ -853,6 +861,8 @@ test "crypto.chacha20 test vector 1" {
}
test "crypto.chacha20 test vector 2" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const expected_result = [_]u8{
0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96,
0xd7, 0x73, 0x6e, 0x7b, 0x20, 0x8e, 0x3c, 0x96,
@@ -887,6 +897,8 @@ test "crypto.chacha20 test vector 2" {
}
test "crypto.chacha20 test vector 3" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const expected_result = [_]u8{
0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5,
0xe7, 0x86, 0xdc, 0x63, 0x97, 0x3f, 0x65, 0x3a,
@@ -921,6 +933,8 @@ test "crypto.chacha20 test vector 3" {
}
test "crypto.chacha20 test vector 4" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const expected_result = [_]u8{
0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb,
0xf5, 0xcf, 0x35, 0xbd, 0x3d, 0xd3, 0x3b, 0x80,
@@ -955,6 +969,8 @@ test "crypto.chacha20 test vector 4" {
}
test "crypto.chacha20 test vector 5" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const expected_result = [_]u8{
0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69,
0x82, 0x10, 0x5f, 0xfb, 0x64, 0x0b, 0xb7, 0x75,
@@ -1027,6 +1043,8 @@ test "crypto.chacha20 test vector 5" {
}
test "seal" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
{
const m = "";
const ad = "";
@@ -1077,6 +1095,8 @@ test "seal" {
}
test "open" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
{
const c = [_]u8{ 0xa0, 0x78, 0x4d, 0x7a, 0x47, 0x16, 0xf3, 0xfe, 0xb4, 0xf6, 0x4e, 0x7f, 0x4b, 0x39, 0xbf, 0x4 };
const ad = "";
@@ -1141,6 +1161,8 @@ test "open" {
}
test "crypto.xchacha20" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{69} ** 32;
const nonce = [_]u8{42} ** 24;
const m = "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.";
lib/std/crypto/cmac.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const crypto = std.crypto;
const mem = std.mem;
@@ -93,6 +94,8 @@ pub fn Cmac(comptime BlockCipher: type) type {
const testing = std.testing;
test "CmacAes128 - Example 1: len = 0" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{
0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
};
@@ -106,6 +109,8 @@ test "CmacAes128 - Example 1: len = 0" {
}
test "CmacAes128 - Example 2: len = 16" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{
0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
};
@@ -121,6 +126,8 @@ test "CmacAes128 - Example 2: len = 16" {
}
test "CmacAes128 - Example 3: len = 40" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{
0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
};
@@ -138,6 +145,8 @@ test "CmacAes128 - Example 3: len = 40" {
}
test "CmacAes128 - Example 4: len = 64" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{
0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
};
lib/std/crypto/ghash_polyval.zig
@@ -422,6 +422,8 @@ fn Hash(comptime endian: std.builtin.Endian, comptime shift_key: bool) type {
const htest = @import("test.zig");
test "ghash" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{0x42} ** 16;
const m = [_]u8{0x69} ** 256;
@@ -439,6 +441,8 @@ test "ghash" {
}
test "ghash2" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var key: [16]u8 = undefined;
var i: usize = 0;
while (i < key.len) : (i += 1) {
@@ -472,6 +476,8 @@ test "ghash2" {
}
test "polyval" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{0x42} ** 16;
const m = [_]u8{0x69} ** 256;
lib/std/crypto/hash_composition.zig
@@ -65,6 +65,8 @@ pub const Sha384oSha384 = Composition(sha2.Sha384, sha2.Sha384);
pub const Sha512oSha512 = Composition(sha2.Sha512, sha2.Sha512);
test "Hash composition" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const Sha256 = sha2.Sha256;
const msg = "test";
lib/std/crypto/hkdf.zig
@@ -72,6 +72,8 @@ pub fn Hkdf(comptime Hmac: type) type {
const htest = @import("test.zig");
test "Hkdf" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const ikm = [_]u8{0x0b} ** 22;
const salt = [_]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c };
const context = [_]u8{ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
lib/std/crypto/kyber_d00.zig
@@ -553,6 +553,8 @@ const inv_ntt_reductions = [_]i16{
};
test "invNTTReductions bounds" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// Checks whether the reductions proposed by invNTTReductions
// don't overflow during invNTT().
var xs = [_]i32{1} ** 256; // start at |x| ≤ q
@@ -656,6 +658,8 @@ fn montReduce(x: i32) i16 {
}
test "Test montReduce" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var rnd = RndGen.init(0);
for (0..1000) |_| {
const bound = comptime @as(i32, Q) * (1 << 15);
@@ -674,6 +678,8 @@ fn feToMont(x: i16) i16 {
}
test "Test feToMont" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var x: i32 = -(1 << 15);
while (x < 1 << 15) : (x += 1) {
const y = feToMont(@as(i16, @intCast(x)));
@@ -707,6 +713,8 @@ fn feBarrettReduce(x: i16) i16 {
}
test "Test Barrett reduction" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var x: i32 = -(1 << 15);
while (x < 1 << 15) : (x += 1) {
var y1 = feBarrettReduce(@as(i16, @intCast(x)));
@@ -727,6 +735,8 @@ fn csubq(x: i16) i16 {
}
test "Test csubq" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var x: i32 = -29439;
while (x < 1 << 15) : (x += 1) {
const y1 = csubq(@as(i16, @intCast(x)));
@@ -1466,6 +1476,8 @@ fn cmov(comptime len: usize, dst: *[len]u8, src: [len]u8, b: u1) void {
}
test "MulHat" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var rnd = RndGen.init(0);
for (0..100) |_| {
@@ -1497,6 +1509,8 @@ test "MulHat" {
}
test "NTT" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var rnd = RndGen.init(0);
for (0..1000) |_| {
@@ -1520,6 +1534,8 @@ test "NTT" {
}
test "Compression" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var rnd = RndGen.init(0);
inline for (.{ 1, 4, 5, 10, 11 }) |d| {
for (0..1000) |_| {
@@ -1532,6 +1548,8 @@ test "Compression" {
}
test "noise" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var seed: [32]u8 = undefined;
for (&seed, 0..) |*s, i| {
s.* = @as(u8, @intCast(i));
@@ -1578,6 +1596,8 @@ test "noise" {
}
test "uniform sampling" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var seed: [32]u8 = undefined;
for (&seed, 0..) |*s, i| {
s.* = @as(u8, @intCast(i));
@@ -1611,6 +1631,8 @@ test "uniform sampling" {
}
test "Polynomial packing" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var rnd = RndGen.init(0);
for (0..1000) |_| {
@@ -1620,6 +1642,8 @@ test "Polynomial packing" {
}
test "Test inner PKE" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var seed: [32]u8 = undefined;
var pt: [32]u8 = undefined;
for (&seed, &pt, 0..) |*s, *p, i| {
@@ -1641,6 +1665,8 @@ test "Test inner PKE" {
}
test "Test happy flow" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var seed: [64]u8 = undefined;
for (&seed, 0..) |*s, i| {
s.* = @as(u8, @intCast(i));
@@ -1667,6 +1693,8 @@ test "Test happy flow" {
const sha2 = crypto.hash.sha2;
test "NIST KAT test" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
inline for (.{
.{ Kyber512, "e9c2bd37133fcb40772f81559f14b1f58dccd1c816701be9ba6214d43baf4547" },
.{ Kyber1024, "89248f2f33f7f4f7051729111f3049c409a933ec904aedadf035f30fa5646cd5" },
lib/std/crypto/pbkdf2.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const mem = std.mem;
const maxInt = std.math.maxInt;
const OutputTooLongError = std.crypto.errors.OutputTooLongError;
@@ -151,6 +152,8 @@ const HmacSha1 = std.crypto.auth.hmac.HmacSha1;
// RFC 6070 PBKDF2 HMAC-SHA1 Test Vectors
test "RFC 6070 one iteration" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const p = "password";
const s = "salt";
const c = 1;
@@ -166,6 +169,8 @@ test "RFC 6070 one iteration" {
}
test "RFC 6070 two iterations" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const p = "password";
const s = "salt";
const c = 2;
@@ -181,6 +186,8 @@ test "RFC 6070 two iterations" {
}
test "RFC 6070 4096 iterations" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const p = "password";
const s = "salt";
const c = 4096;
@@ -196,6 +203,8 @@ test "RFC 6070 4096 iterations" {
}
test "RFC 6070 16,777,216 iterations" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// These iteration tests are slow so we always skip them. Results have been verified.
if (true) {
return error.SkipZigTest;
@@ -216,6 +225,8 @@ test "RFC 6070 16,777,216 iterations" {
}
test "RFC 6070 multi-block salt and password" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const p = "passwordPASSWORDpassword";
const s = "saltSALTsaltSALTsaltSALTsaltSALTsalt";
const c = 4096;
@@ -231,6 +242,8 @@ test "RFC 6070 multi-block salt and password" {
}
test "RFC 6070 embedded NUL" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const p = "pass\x00word";
const s = "sa\x00lt";
const c = 4096;
@@ -246,6 +259,8 @@ test "RFC 6070 embedded NUL" {
}
test "Very large dk_len" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// This test allocates 8GB of memory and is expected to take several hours to run.
if (true) {
return error.SkipZigTest;
lib/std/crypto/phc_encoding.zig
@@ -1,6 +1,7 @@
// https://github.com/P-H-C/phc-string-format
const std = @import("std");
+const builtin = @import("builtin");
const fmt = std.fmt;
const io = std.io;
const mem = std.mem;
@@ -263,6 +264,8 @@ fn kvSplit(str: []const u8) !struct { key: []const u8, value: []const u8 } {
}
test "phc format - encoding/decoding" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const Input = struct {
str: []const u8,
HashResult: type,
@@ -348,18 +351,24 @@ test "phc format - encoding/decoding" {
}
test "phc format - empty input string" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const s = "";
const v = deserialize(struct { alg_id: []const u8 }, s);
try std.testing.expectError(Error.InvalidEncoding, v);
}
test "phc format - hash without salt" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const s = "$scrypt";
const v = deserialize(struct { alg_id: []const u8, hash: BinValue(16) }, s);
try std.testing.expectError(Error.InvalidEncoding, v);
}
test "phc format - calcSize" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const s = "$scrypt$v=1$ln=15,r=8,p=1$c2FsdHNhbHQ$dGVzdHBhc3M";
const v = try deserialize(struct {
alg_id: []const u8,
lib/std/crypto/salsa20.zig
@@ -555,6 +555,8 @@ pub const SealedBox = struct {
const htest = @import("test.zig");
test "(x)salsa20" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{0x69} ** 32;
const nonce = [_]u8{0x42} ** 8;
const msg = [_]u8{0} ** 20;
@@ -569,6 +571,8 @@ test "(x)salsa20" {
}
test "xsalsa20poly1305" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var msg: [100]u8 = undefined;
var msg2: [msg.len]u8 = undefined;
var c: [msg.len]u8 = undefined;
@@ -584,6 +588,8 @@ test "xsalsa20poly1305" {
}
test "xsalsa20poly1305 secretbox" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var msg: [100]u8 = undefined;
var msg2: [msg.len]u8 = undefined;
var key: [XSalsa20Poly1305.key_length]u8 = undefined;
@@ -598,6 +604,8 @@ test "xsalsa20poly1305 secretbox" {
}
test "xsalsa20poly1305 box" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var msg: [100]u8 = undefined;
var msg2: [msg.len]u8 = undefined;
var nonce: [Box.nonce_length]u8 = undefined;
@@ -612,6 +620,8 @@ test "xsalsa20poly1305 box" {
}
test "xsalsa20poly1305 sealedbox" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var msg: [100]u8 = undefined;
var msg2: [msg.len]u8 = undefined;
var boxed: [msg.len + SealedBox.seal_length]u8 = undefined;
@@ -623,6 +633,8 @@ test "xsalsa20poly1305 sealedbox" {
}
test "secretbox twoblocks" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const key = [_]u8{ 0xc9, 0xc9, 0x4d, 0xcf, 0x68, 0xbe, 0x00, 0xe4, 0x7f, 0xe6, 0x13, 0x26, 0xfc, 0xc4, 0x2f, 0xd0, 0xdb, 0x93, 0x91, 0x1c, 0x09, 0x94, 0x89, 0xe1, 0x1b, 0x88, 0x63, 0x18, 0x86, 0x64, 0x8b, 0x7b };
const nonce = [_]u8{ 0xa4, 0x33, 0xe9, 0x0a, 0x07, 0x68, 0x6e, 0x9a, 0x2b, 0x6d, 0xd4, 0x59, 0x04, 0x72, 0x3e, 0xd3, 0x8a, 0x67, 0x55, 0xc7, 0x9e, 0x3e, 0x77, 0xdc };
const msg = [_]u8{'a'} ** 97;
lib/std/crypto/scrypt.zig
@@ -683,6 +683,8 @@ test "unix-scrypt" {
}
test "crypt format" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const str = "$7$C6..../....SodiumChloride$kBGj9fHznVYFQMEn/qDCfrDevf9YDtcDdKvEqHJLV8D";
const params = try crypt_format.deserialize(crypt_format.HashResult(32), str);
var buf: [str.len]u8 = undefined;
lib/std/crypto/sha2.zig
@@ -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 != .stage2_c and builtin.zig_backend != .stage2_x86_64 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));
@@ -406,12 +406,16 @@ fn Sha2x32(comptime params: Sha2Params32) type {
}
test "sha224 single" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try htest.assertEqualHash(Sha224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", "");
try htest.assertEqualHash(Sha224, "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", "abc");
try htest.assertEqualHash(Sha224, "c97ca9a559850ce97a04a96def6d99a9e0e0e2ab14e6b8df265fc0b3", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
}
test "sha224 streaming" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var h = Sha224.init(.{});
var out: [28]u8 = undefined;
@@ -432,12 +436,16 @@ test "sha224 streaming" {
}
test "sha256 single" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try htest.assertEqualHash(Sha256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "");
try htest.assertEqualHash(Sha256, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", "abc");
try htest.assertEqualHash(Sha256, "cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
}
test "sha256 streaming" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var h = Sha256.init(.{});
var out: [32]u8 = undefined;
@@ -458,6 +466,8 @@ test "sha256 streaming" {
}
test "sha256 aligned final" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var block = [_]u8{0} ** Sha256.block_length;
var out: [Sha256.digest_length]u8 = undefined;
lib/std/crypto/utils.zig
@@ -149,6 +149,8 @@ test "crypto.utils.timingSafeEql" {
}
test "crypto.utils.timingSafeEql (vectors)" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a: [100]u8 = undefined;
var b: [100]u8 = undefined;
random.bytes(a[0..]);
lib/std/fmt/parse_float.zig
@@ -1,8 +1,8 @@
pub const parseFloat = @import("parse_float/parse_float.zig").parseFloat;
pub const ParseFloatError = @import("parse_float/parse_float.zig").ParseFloatError;
-const builtin = @import("builtin");
const std = @import("std");
+const builtin = @import("builtin");
const math = std.math;
const testing = std.testing;
const expect = testing.expect;
@@ -14,6 +14,8 @@ const epsilon = 1e-7;
// See https://github.com/tiehuis/parse-number-fxx-test-data for a wider-selection of test-data.
test "fmt.parseFloat" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
inline for ([_]type{ f16, f32, f64, f128 }) |T| {
try testing.expectError(error.InvalidCharacter, parseFloat(T, ""));
try testing.expectError(error.InvalidCharacter, parseFloat(T, " 1"));
@@ -70,6 +72,8 @@ test "fmt.parseFloat" {
}
test "fmt.parseFloat nan and inf" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
inline for ([_]type{ f16, f32, f64, f128 }) |T| {
const Z = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
@@ -80,16 +84,22 @@ test "fmt.parseFloat nan and inf" {
}
test "fmt.parseFloat #11169" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try expectEqual(try parseFloat(f128, "9007199254740993.0"), 9007199254740993.0);
}
test "fmt.parseFloat hex.special" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testing.expect(math.isNan(try parseFloat(f32, "nAn")));
try testing.expect(math.isPositiveInf(try parseFloat(f32, "iNf")));
try testing.expect(math.isPositiveInf(try parseFloat(f32, "+Inf")));
try testing.expect(math.isNegativeInf(try parseFloat(f32, "-iNf")));
}
test "fmt.parseFloat hex.zero" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testing.expectEqual(@as(f32, 0.0), try parseFloat(f32, "0x0"));
try testing.expectEqual(@as(f32, 0.0), try parseFloat(f32, "-0x0"));
try testing.expectEqual(@as(f32, 0.0), try parseFloat(f32, "0x0p42"));
@@ -98,6 +108,8 @@ test "fmt.parseFloat hex.zero" {
}
test "fmt.parseFloat hex.f16" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testing.expectEqual(try parseFloat(f16, "0x1p0"), 1.0);
try testing.expectEqual(try parseFloat(f16, "-0x1p-1"), -0.5);
try testing.expectEqual(try parseFloat(f16, "0x10p+10"), 16384.0);
@@ -114,6 +126,8 @@ test "fmt.parseFloat hex.f16" {
}
test "fmt.parseFloat hex.f32" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testing.expectError(error.InvalidCharacter, parseFloat(f32, "0x"));
try testing.expectEqual(try parseFloat(f32, "0x1p0"), 1.0);
try testing.expectEqual(try parseFloat(f32, "-0x1p-1"), -0.5);
@@ -148,6 +162,8 @@ test "fmt.parseFloat hex.f64" {
try testing.expectEqual(try parseFloat(f64, "-0x1p-1074"), -math.floatTrueMin(f64));
}
test "fmt.parseFloat hex.f128" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testing.expectEqual(try parseFloat(f128, "0x1p0"), 1.0);
try testing.expectEqual(try parseFloat(f128, "-0x1p-1"), -0.5);
try testing.expectEqual(try parseFloat(f128, "0x10p+10"), 16384.0);
lib/std/fs/test.zig
@@ -124,6 +124,8 @@ fn testWithAllSupportedPathTypes(test_func: anytype) !void {
}
test "Dir.readLink" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
// Create some targets
@@ -161,6 +163,8 @@ fn testReadLink(dir: Dir, target_path: []const u8, symlink_path: []const u8) !vo
}
test "relative symlink to parent directory" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -178,6 +182,8 @@ test "relative symlink to parent directory" {
}
test "openDir" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const allocator = ctx.arena.allocator();
@@ -196,6 +202,8 @@ test "openDir" {
test "accessAbsolute" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -214,6 +222,8 @@ test "accessAbsolute" {
test "openDirAbsolute" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -252,6 +262,8 @@ test "openDir non-cwd parent .." {
else => {},
}
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -273,6 +285,8 @@ test "openDir non-cwd parent .." {
test "readLinkAbsolute" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -323,6 +337,8 @@ fn testReadLinkAbsolute(target_path: []const u8, symlink_path: []const u8) !void
}
test "Dir.Iterator" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp_dir = tmpIterableDir(.{});
defer tmp_dir.cleanup();
@@ -353,6 +369,8 @@ test "Dir.Iterator" {
}
test "Dir.Iterator many entries" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp_dir = tmpIterableDir(.{});
defer tmp_dir.cleanup();
@@ -388,6 +406,8 @@ test "Dir.Iterator many entries" {
}
test "Dir.Iterator twice" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp_dir = tmpIterableDir(.{});
defer tmp_dir.cleanup();
@@ -421,6 +441,8 @@ test "Dir.Iterator twice" {
}
test "Dir.Iterator reset" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp_dir = tmpIterableDir(.{});
defer tmp_dir.cleanup();
@@ -457,6 +479,8 @@ test "Dir.Iterator reset" {
}
test "Dir.Iterator but dir is deleted during iteration" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
@@ -499,6 +523,8 @@ fn contains(entries: *const std.ArrayList(IterableDir.Entry), el: IterableDir.En
test "Dir.realpath smoke test" {
if (!comptime std.os.isGetFdPathSupportedOnTarget(builtin.os)) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const allocator = ctx.arena.allocator();
@@ -549,6 +575,8 @@ test "Dir.realpath smoke test" {
}
test "readAllAlloc" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp_dir = tmpDir(.{});
defer tmp_dir.cleanup();
@@ -585,6 +613,8 @@ test "Dir.statFile" {
// TODO: Re-enable once https://github.com/ziglang/zig/issues/17034 is solved
if (builtin.os.tag == .linux and builtin.link_libc and builtin.abi == .gnu) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const test_file_name = try ctx.transformPath("test_file");
@@ -600,6 +630,8 @@ test "Dir.statFile" {
}
test "directory operations on files" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const test_file_name = try ctx.transformPath("test_file");
@@ -629,6 +661,8 @@ test "file operations on directories" {
// TODO: fix this test on FreeBSD. https://github.com/ziglang/zig/issues/1759
if (builtin.os.tag == .freebsd) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const test_dir_name = try ctx.transformPath("test_dir");
@@ -664,6 +698,8 @@ test "file operations on directories" {
}
test "deleteDir" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const test_dir_path = try ctx.transformPath("test_dir");
@@ -685,6 +721,8 @@ test "deleteDir" {
}
test "Dir.rename files" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
// Rename on Windows can hit intermittent AccessDenied errors
@@ -727,6 +765,8 @@ test "Dir.rename files" {
}
test "Dir.rename directories" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
// Rename on Windows can hit intermittent AccessDenied errors
@@ -768,6 +808,8 @@ test "Dir.rename directory onto empty dir" {
// TODO: Fix on Windows, see https://github.com/ziglang/zig/issues/6364
if (builtin.os.tag == .windows) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const test_dir_path = try ctx.transformPath("test_dir");
@@ -789,6 +831,8 @@ test "Dir.rename directory onto non-empty dir" {
// TODO: Fix on Windows, see https://github.com/ziglang/zig/issues/6364
if (builtin.os.tag == .windows) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const test_dir_path = try ctx.transformPath("test_dir");
@@ -815,6 +859,8 @@ test "Dir.rename file <-> dir" {
// TODO: Fix on Windows, see https://github.com/ziglang/zig/issues/6364
if (builtin.os.tag == .windows) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const test_file_path = try ctx.transformPath("test_file");
@@ -830,6 +876,8 @@ test "Dir.rename file <-> dir" {
}
test "rename" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp_dir1 = tmpDir(.{});
defer tmp_dir1.cleanup();
@@ -852,6 +900,8 @@ test "rename" {
test "renameAbsolute" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp_dir = tmpDir(.{});
defer tmp_dir.cleanup();
@@ -910,6 +960,8 @@ test "openSelfExe" {
}
test "makePath, put some files in it, deleteTree" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const allocator = ctx.arena.allocator();
@@ -926,6 +978,8 @@ test "makePath, put some files in it, deleteTree" {
}
test "makePath, put some files in it, deleteTreeMinStackSize" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const allocator = ctx.arena.allocator();
@@ -944,6 +998,8 @@ test "makePath, put some files in it, deleteTreeMinStackSize" {
test "makePath in a directory that no longer exists" {
if (builtin.os.tag == .windows) return error.SkipZigTest; // Windows returns FileBusy if attempting to remove an open dir
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
try tmp.parent_dir.deleteTree(&tmp.sub_path);
@@ -975,6 +1031,8 @@ fn testFilenameLimits(iterable_dir: IterableDir, maxed_filename: []const u8) !vo
}
test "max file name component lengths" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpIterableDir(.{});
defer tmp.cleanup();
@@ -996,6 +1054,8 @@ test "max file name component lengths" {
}
test "writev, readv" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1038,6 +1098,8 @@ test "writev, readv" {
}
test "pwritev, preadv" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1079,6 +1141,8 @@ test "pwritev, preadv" {
}
test "access file" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const dir_path = try ctx.transformPath("os_test_tmp");
@@ -1095,6 +1159,8 @@ test "access file" {
}
test "sendfile" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1160,6 +1226,8 @@ test "sendfile" {
}
test "copyRangeAll" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1186,6 +1254,8 @@ test "copyRangeAll" {
}
test "copyFile" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const data = "u6wj+JmdF3qHsFPE BUlH2g4gJCmEz0PP";
@@ -1216,6 +1286,8 @@ fn expectFileContents(dir: Dir, file_path: []const u8, data: []const u8) !void {
}
test "AtomicFile" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const allocator = ctx.arena.allocator();
@@ -1242,6 +1314,8 @@ test "AtomicFile" {
test "open file with exclusive nonblocking lock twice" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const filename = try ctx.transformPath("file_nonblocking_lock_test.txt");
@@ -1258,6 +1332,8 @@ test "open file with exclusive nonblocking lock twice" {
test "open file with shared and exclusive nonblocking lock" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const filename = try ctx.transformPath("file_nonblocking_lock_test.txt");
@@ -1274,6 +1350,8 @@ test "open file with shared and exclusive nonblocking lock" {
test "open file with exclusive and shared nonblocking lock" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testWithAllSupportedPathTypes(struct {
fn impl(ctx: *TestContext) !void {
const filename = try ctx.transformPath("file_nonblocking_lock_test.txt");
@@ -1288,6 +1366,8 @@ test "open file with exclusive and shared nonblocking lock" {
}
test "open file with exclusive lock twice, make sure second lock waits" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (builtin.single_threaded) return error.SkipZigTest;
if (std.io.is_async) {
@@ -1338,6 +1418,8 @@ test "open file with exclusive lock twice, make sure second lock waits" {
test "open file with exclusive nonblocking lock twice (absolute paths)" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var random_bytes: [12]u8 = undefined;
std.crypto.random.bytes(&random_bytes);
@@ -1372,6 +1454,8 @@ test "open file with exclusive nonblocking lock twice (absolute paths)" {
test "walker" {
if (builtin.os.tag == .wasi and builtin.link_libc) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpIterableDir(.{});
defer tmp.cleanup();
@@ -1425,6 +1509,8 @@ test "walker" {
test "walker without fully iterating" {
if (builtin.os.tag == .wasi and builtin.link_libc) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpIterableDir(.{});
defer tmp.cleanup();
@@ -1448,6 +1534,8 @@ test "walker without fully iterating" {
test ". and .. in fs.Dir functions" {
if (builtin.os.tag == .wasi and builtin.link_libc) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (builtin.os.tag == .windows and builtin.cpu.arch == .aarch64) {
// https://github.com/ziglang/zig/issues/17134
return error.SkipZigTest;
@@ -1488,6 +1576,8 @@ test ". and .. in fs.Dir functions" {
test ". and .. in absolute functions" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1533,6 +1623,8 @@ test "chmod" {
if (builtin.os.tag == .windows or builtin.os.tag == .wasi)
return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1555,6 +1647,8 @@ test "chown" {
if (builtin.os.tag == .windows or builtin.os.tag == .wasi)
return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1570,6 +1664,8 @@ test "chown" {
}
test "File.Metadata" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1588,6 +1684,8 @@ test "File.Permissions" {
if (builtin.os.tag == .wasi)
return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1614,6 +1712,8 @@ test "File.PermissionsUnix" {
if (builtin.os.tag == .windows or builtin.os.tag == .wasi)
return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1649,6 +1749,8 @@ test "delete a read-only file on windows" {
if (builtin.os.tag != .windows)
return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = testing.tmpDir(.{});
defer tmp.cleanup();
@@ -1679,6 +1781,8 @@ test "delete a read-only file on windows" {
test "delete a setAsCwd directory on Windows" {
if (builtin.os.tag != .windows) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
// Set tmp dir as current working directory.
try tmp.dir.setAsCwd();
lib/std/hash/xxhash.zig
@@ -803,6 +803,8 @@ fn testExpect(comptime H: type, seed: anytype, input: []const u8, expected: u64)
}
test "xxhash3" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const H = XxHash3;
// Non-Seeded Tests
try testExpect(H, 0, "", 0x2d06800538d394c2);
@@ -834,6 +836,8 @@ test "xxhash3" {
}
test "xxhash3 smhasher" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const Test = struct {
fn do() !void {
try expectEqual(verify.smhasher(XxHash3.hash), 0x9a636405);
@@ -845,6 +849,8 @@ test "xxhash3 smhasher" {
}
test "xxhash3 iterative api" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const Test = struct {
fn do() !void {
try verify.iterativeApi(XxHash3);
@@ -856,6 +862,8 @@ test "xxhash3 iterative api" {
}
test "xxhash64" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const H = XxHash64;
try testExpect(H, 0, "", 0xef46db3751d8e999);
try testExpect(H, 0, "a", 0xd24ec4f1a98c6e5b);
@@ -867,6 +875,8 @@ test "xxhash64" {
}
test "xxhash64 smhasher" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const Test = struct {
fn do() !void {
try expectEqual(verify.smhasher(XxHash64.hash), 0x024B7CF4);
@@ -878,6 +888,8 @@ test "xxhash64 smhasher" {
}
test "xxhash64 iterative api" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const Test = struct {
fn do() !void {
try verify.iterativeApi(XxHash64);
@@ -889,6 +901,8 @@ test "xxhash64 iterative api" {
}
test "xxhash32" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const H = XxHash32;
try testExpect(H, 0, "", 0x02cc5d05);
@@ -901,6 +915,8 @@ test "xxhash32" {
}
test "xxhash32 smhasher" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const Test = struct {
fn do() !void {
try expectEqual(verify.smhasher(XxHash32.hash), 0xBA88B743);
@@ -912,6 +928,8 @@ test "xxhash32 smhasher" {
}
test "xxhash32 iterative api" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const Test = struct {
fn do() !void {
try verify.iterativeApi(XxHash32);
lib/std/http/Client.zig
@@ -1,6 +1,7 @@
//! Connecting and opening requests are threadsafe. Individual requests are not.
const std = @import("../std.zig");
+const builtin = @import("builtin");
const testing = std.testing;
const http = std.http;
const mem = std.mem;
@@ -427,6 +428,8 @@ pub const Response = struct {
}
test parseInt3 {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const expectEqual = testing.expectEqual;
try expectEqual(@as(u10, 0), parseInt3("000".*));
try expectEqual(@as(u10, 418), parseInt3("418".*));
@@ -585,7 +588,7 @@ pub const Request = struct {
if (!req.headers.contains("user-agent")) {
try w.writeAll("User-Agent: zig/");
- try w.writeAll(@import("builtin").zig_version_string);
+ try w.writeAll(builtin.zig_version_string);
try w.writeAll(" (std.http)\r\n");
}
@@ -1249,7 +1252,6 @@ pub fn fetch(client: *Client, allocator: Allocator, options: FetchOptions) !Fetc
}
test {
- const builtin = @import("builtin");
const native_endian = comptime builtin.cpu.arch.endian();
if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) {
// https://github.com/ziglang/zig/issues/13782
@@ -1258,5 +1260,7 @@ test {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
std.testing.refAllDecls(@This());
}
lib/std/http/Server.zig
@@ -725,6 +725,8 @@ test "HTTP server handles a chunked transfer coding request" {
return error.SkipZigTest;
}
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const native_endian = comptime builtin.cpu.arch.endian();
if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) {
// https://github.com/ziglang/zig/issues/13782
lib/std/io/multi_writer.zig
@@ -36,6 +36,7 @@ pub fn multiWriter(streams: anytype) MultiWriter(@TypeOf(streams)) {
const testing = std.testing;
test "MultiWriter" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
var tmp = testing.tmpDir(.{});
defer tmp.cleanup();
var f = try tmp.dir.createFile("t.txt", .{});
lib/std/io/test.zig
@@ -15,6 +15,8 @@ const native_endian = builtin.target.cpu.arch.endian();
const tmpDir = std.testing.tmpDir;
test "write a file, read it, then delete it" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -61,6 +63,8 @@ test "write a file, read it, then delete it" {
}
test "BitStreams with File Stream" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -106,6 +110,8 @@ test "BitStreams with File Stream" {
}
test "File seek ops" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -133,6 +139,8 @@ test "File seek ops" {
}
test "setEndPos" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -159,6 +167,8 @@ test "setEndPos" {
}
test "updateTimes" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
lib/std/json/dynamic_test.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const mem = std.mem;
const testing = std.testing;
const ArenaAllocator = std.heap.ArenaAllocator;
@@ -18,6 +19,8 @@ const jsonReader = @import("scanner.zig").reader;
const JsonReader = @import("scanner.zig").Reader;
test "json.parser.dynamic" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const s =
\\{
\\ "Image": {
@@ -72,6 +75,8 @@ test "json.parser.dynamic" {
const writeStream = @import("./stringify.zig").writeStream;
test "write json then parse it" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var out_buffer: [1000]u8 = undefined;
var fixed_buffer_stream = std.io.fixedBufferStream(&out_buffer);
@@ -120,12 +125,16 @@ fn testParse(allocator: std.mem.Allocator, json_str: []const u8) !Value {
}
test "parsing empty string gives appropriate error" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_allocator.deinit();
try testing.expectError(error.UnexpectedEndOfInput, testParse(arena_allocator.allocator(), ""));
}
test "Value.array allocator should still be usable after parsing" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var parsed = try parseFromSlice(Value, std.testing.allocator, "[]", .{});
defer parsed.deinit();
@@ -138,6 +147,8 @@ test "Value.array allocator should still be usable after parsing" {
}
test "integer after float has proper type" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_allocator.deinit();
const parsed = try testParse(arena_allocator.allocator(),
@@ -150,6 +161,8 @@ test "integer after float has proper type" {
}
test "escaped characters" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_allocator.deinit();
const input =
@@ -182,6 +195,8 @@ test "escaped characters" {
}
test "Value.jsonStringify" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var vals = [_]Value{
.{ .integer = 1 },
.{ .integer = 2 },
@@ -229,6 +244,8 @@ test "Value.jsonStringify" {
}
test "parseFromValue(std.json.Value,...)" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const str =
\\{
\\ "int": 32,
@@ -246,6 +263,8 @@ test "parseFromValue(std.json.Value,...)" {
}
test "polymorphic parsing" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (true) return error.SkipZigTest; // See https://github.com/ziglang/zig/issues/16108
const doc =
\\{ "type": "div",
@@ -291,6 +310,8 @@ test "polymorphic parsing" {
}
test "long object value" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const value = "01234567890123456789";
const doc = "{\"key\":\"" ++ value ++ "\"}";
var fbs = std.io.fixedBufferStream(doc);
@@ -303,6 +324,8 @@ test "long object value" {
}
test "ParseOptions.max_value_len" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var arena = ArenaAllocator.init(testing.allocator);
defer arena.deinit();
@@ -317,6 +340,8 @@ test "ParseOptions.max_value_len" {
}
test "many object keys" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const doc =
\\{
\\ "k1": "v1",
lib/std/json/hashmap_test.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const testing = std.testing;
const ArrayHashMap = @import("hashmap.zig").ArrayHashMap;
@@ -18,6 +19,8 @@ const T = struct {
};
test "parse json hashmap" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const doc =
\\{
\\ "abc": {"i": 0, "s": "d"},
@@ -33,6 +36,8 @@ test "parse json hashmap" {
}
test "parse json hashmap while streaming" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const doc =
\\{
\\ "abc": {"i": 0, "s": "d"},
@@ -58,6 +63,8 @@ test "parse json hashmap while streaming" {
}
test "parse json hashmap duplicate fields" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
@@ -86,6 +93,8 @@ test "parse json hashmap duplicate fields" {
}
test "stringify json hashmap" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var value = ArrayHashMap(T){};
defer value.deinit(testing.allocator);
{
@@ -123,6 +132,8 @@ test "stringify json hashmap" {
}
test "stringify json hashmap whitespace" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var value = ArrayHashMap(T){};
defer value.deinit(testing.allocator);
try value.map.put(testing.allocator, "abc", .{ .i = 0, .s = "d" });
@@ -147,6 +158,8 @@ test "stringify json hashmap whitespace" {
}
test "json parse from value hashmap" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const doc =
\\{
\\ "abc": {"i": 0, "s": "d"},
lib/std/json/static_test.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const testing = std.testing;
const ArenaAllocator = std.heap.ArenaAllocator;
const Allocator = std.mem.Allocator;
@@ -371,6 +372,8 @@ test "test all types" {
}
test "parse" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testing.expectEqual(false, try parseFromSliceLeaky(bool, testing.allocator, "false", .{}));
try testing.expectEqual(true, try parseFromSliceLeaky(bool, testing.allocator, "true", .{}));
try testing.expectEqual(@as(u1, 1), try parseFromSliceLeaky(u1, testing.allocator, "1", .{}));
@@ -389,6 +392,8 @@ test "parse" {
}
test "parse into enum" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = enum(u32) {
Foo = 42,
Bar,
@@ -402,6 +407,8 @@ test "parse into enum" {
}
test "parse into that allocates a slice" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
{
// string as string
const parsed = try parseFromSlice([]u8, testing.allocator, "\"foo\"", .{});
@@ -422,12 +429,16 @@ test "parse into that allocates a slice" {
}
test "parse into sentinel slice" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const parsed = try parseFromSlice([:0]const u8, testing.allocator, "\"\\n\"", .{});
defer parsed.deinit();
try testing.expect(std.mem.eql(u8, parsed.value, "\n"));
}
test "parse into tagged union" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = union(enum) {
nothing,
int: i32,
@@ -443,6 +454,8 @@ test "parse into tagged union" {
}
test "parse into tagged union errors" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = union(enum) {
nothing,
int: i32,
@@ -465,6 +478,8 @@ test "parse into tagged union errors" {
}
test "parse into struct with no fields" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct {};
const parsed = try parseFromSlice(T, testing.allocator, "{}", .{});
defer parsed.deinit();
@@ -474,6 +489,8 @@ test "parse into struct with no fields" {
const test_const_value: usize = 123;
test "parse into struct with default const pointer field" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct { a: *const usize = &test_const_value };
const parsed = try parseFromSlice(T, testing.allocator, "{}", .{});
defer parsed.deinit();
@@ -489,6 +506,8 @@ const test_default_str_slice: [2][]const u8 = [_][]const u8{
};
test "freeing parsed structs with pointers to default values" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct {
int: *const usize = &test_default_usize,
int_ptr: *allowzero align(1) const usize = test_default_usize_ptr,
@@ -502,11 +521,15 @@ test "freeing parsed structs with pointers to default values" {
}
test "parse into struct where destination and source lengths mismatch" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct { a: [2]u8 };
try testing.expectError(error.LengthMismatch, parseFromSlice(T, testing.allocator, "{\"a\": \"bbb\"}", .{}));
}
test "parse into struct with misc fields" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct {
int: i64,
float: f64,
@@ -582,6 +605,8 @@ test "parse into struct with misc fields" {
}
test "parse into struct with strings and arrays with sentinels" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct {
language: [:0]const u8,
language_without_sentinel: []const u8,
@@ -610,6 +635,8 @@ test "parse into struct with strings and arrays with sentinels" {
}
test "parse into struct with duplicate field" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const options_first = ParseOptions{ .duplicate_field_behavior = .use_first };
const options_last = ParseOptions{ .duplicate_field_behavior = .use_last };
@@ -629,6 +656,8 @@ test "parse into struct with duplicate field" {
}
test "parse into struct ignoring unknown fields" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct {
int: i64,
language: []const u8,
@@ -667,6 +696,8 @@ test "parse into struct ignoring unknown fields" {
}
test "parse into tuple" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const Union = union(enum) {
char: u8,
float: f64,
@@ -722,6 +753,8 @@ const ParseIntoRecursiveUnionDefinitionValue = union(enum) {
};
test "parse into recursive union definition" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct {
values: ParseIntoRecursiveUnionDefinitionValue,
};
@@ -743,6 +776,8 @@ const ParseIntoDoubleRecursiveUnionValueSecond = union(enum) {
};
test "parse into double recursive union definition" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct {
values: ParseIntoDoubleRecursiveUnionValueFirst,
};
@@ -754,6 +789,8 @@ test "parse into double recursive union definition" {
}
test "parse exponential into int" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct { int: i64 };
const r = try parseFromSliceLeaky(T, testing.allocator, "{ \"int\": 4.2e2 }", .{});
try testing.expectEqual(@as(i64, 420), r.int);
@@ -762,6 +799,8 @@ test "parse exponential into int" {
}
test "parseFromTokenSource" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
{
var scanner = JsonScanner.initCompleteInput(testing.allocator, "123");
defer scanner.deinit();
@@ -781,10 +820,14 @@ test "parseFromTokenSource" {
}
test "max_value_len" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testing.expectError(error.ValueTooLong, parseFromSlice([]u8, testing.allocator, "\"0123456789\"", .{ .max_value_len = 5 }));
}
test "parse into vector" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct {
vec_i32: @Vector(4, i32),
vec_f32: @Vector(2, f32),
@@ -817,6 +860,8 @@ fn assertKey(
}
}
test "json parse partial" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const Inner = struct {
num: u32,
yes: bool,
@@ -872,6 +917,8 @@ test "json parse partial" {
}
test "json parse allocate when streaming" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = struct {
not_const: []u8,
is_const: []const u8,
@@ -902,6 +949,8 @@ test "json parse allocate when streaming" {
}
test "parse at comptime" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const doc =
\\{
\\ "vals": {
lib/std/json/stringify_test.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const mem = std.mem;
const testing = std.testing;
@@ -15,6 +16,8 @@ const writeStreamMaxDepth = @import("stringify.zig").writeStreamMaxDepth;
const writeStreamArbitraryDepth = @import("stringify.zig").writeStreamArbitraryDepth;
test "json write stream" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var out_buf: [1024]u8 = undefined;
var slice_stream = std.io.fixedBufferStream(&out_buf);
const out = slice_stream.writer();
@@ -97,6 +100,8 @@ fn getJsonObject(allocator: std.mem.Allocator) !Value {
}
test "stringify null optional fields" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const MyStruct = struct {
optional: ?[]const u8 = null,
required: []const u8 = "something",
@@ -118,6 +123,8 @@ test "stringify null optional fields" {
}
test "stringify basic types" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testStringify("false", false, .{});
try testStringify("true", true, .{});
try testStringify("null", @as(?u8, null), .{});
@@ -134,6 +141,8 @@ test "stringify basic types" {
}
test "stringify string" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testStringify("\"hello\"", "hello", .{});
try testStringify("\"with\\nescapes\\r\"", "with\nescapes\r", .{});
try testStringify("\"with\\nescapes\\r\"", "with\nescapes\r", .{ .escape_unicode = true });
@@ -158,12 +167,16 @@ test "stringify string" {
}
test "stringify many-item sentinel-terminated string" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testStringify("\"hello\"", @as([*:0]const u8, "hello"), .{});
try testStringify("\"with\\nescapes\\r\"", @as([*:0]const u8, "with\nescapes\r"), .{ .escape_unicode = true });
try testStringify("\"with unicode\\u0001\"", @as([*:0]const u8, "with unicode\u{1}"), .{ .escape_unicode = true });
}
test "stringify enums" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const E = enum {
foo,
bar,
@@ -173,11 +186,15 @@ test "stringify enums" {
}
test "stringify enum literals" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testStringify("\"foo\"", .foo, .{});
try testStringify("\"bar\"", .bar, .{});
}
test "stringify tagged unions" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const T = union(enum) {
nothing,
foo: u32,
@@ -189,12 +206,16 @@ test "stringify tagged unions" {
}
test "stringify struct" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testStringify("{\"foo\":42}", struct {
foo: u32,
}{ .foo = 42 }, .{});
}
test "emit_strings_as_arrays" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// Should only affect string values, not object keys.
try testStringify("{\"foo\":\"bar\"}", .{ .foo = "bar" }, .{});
try testStringify("{\"foo\":[98,97,114]}", .{ .foo = "bar" }, .{ .emit_strings_as_arrays = true });
@@ -209,6 +230,8 @@ test "emit_strings_as_arrays" {
}
test "stringify struct with indentation" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testStringify(
\\{
\\ "foo": 42,
@@ -254,6 +277,8 @@ test "stringify struct with indentation" {
}
test "stringify struct with void field" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testStringify("{\"foo\":42}", struct {
foo: u32,
bar: void = {},
@@ -261,6 +286,8 @@ test "stringify struct with void field" {
}
test "stringify array of structs" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const MyStruct = struct {
foo: u32,
};
@@ -272,6 +299,8 @@ test "stringify array of structs" {
}
test "stringify struct with custom stringifier" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testStringify("[\"something special\",42]", struct {
foo: u32,
const Self = @This();
@@ -286,12 +315,16 @@ test "stringify struct with custom stringifier" {
}
test "stringify vector" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testStringify("[1,1]", @as(@Vector(2, u32), @splat(1)), .{});
try testStringify("\"AA\"", @as(@Vector(2, u8), @splat('A')), .{});
try testStringify("[65,65]", @as(@Vector(2, u8), @splat('A')), .{ .emit_strings_as_arrays = true });
}
test "stringify tuple" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testStringify("[\"foo\",42]", std.meta.Tuple(&.{ []const u8, usize }){ "foo", 42 }, .{});
}
@@ -378,6 +411,8 @@ fn testStringifyArbitraryDepth(expected: []const u8, value: anytype, options: St
}
test "stringify alloc" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const allocator = std.testing.allocator;
const expected =
\\{"foo":"bar","answer":42,"my_friend":"sammy"}
@@ -389,6 +424,8 @@ test "stringify alloc" {
}
test "comptime stringify" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
comptime testStringifyMaxDepth("false", false, .{}, null) catch unreachable;
comptime testStringifyMaxDepth("false", false, .{}, 0) catch unreachable;
comptime testStringifyArbitraryDepth("false", false, .{}) catch unreachable;
@@ -409,6 +446,8 @@ test "comptime stringify" {
}
test "print" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var out_buf: [1024]u8 = undefined;
var slice_stream = std.io.fixedBufferStream(&out_buf);
const out = slice_stream.writer();
@@ -440,6 +479,8 @@ test "print" {
}
test "nonportable numbers" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testStringify("9999999999999999", 9999999999999999, .{});
try testStringify("\"9999999999999999\"", 9999999999999999, .{ .emit_nonportable_numbers_as_strings = true });
}
lib/std/json/test.zig
@@ -34,6 +34,8 @@ fn testHighLevelDynamicParser(s: []const u8) !void {
// Additional tests not part of test JSONTestSuite.
test "y_trailing_comma_after_empty" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try roundTrip(
\\{"1":[],"2":{},"3":"4"}
);
lib/std/math/big/int_test.zig
@@ -915,7 +915,10 @@ test "big.int mul multi-single" {
}
test "big.int mul multi-multi" {
- if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
var op1: u256 = 0x998888efefefefefefefef;
var op2: u256 = 0x333000abababababababab;
@@ -1036,7 +1039,10 @@ test "big.int mulWrap single-single signed" {
}
test "big.int mulWrap multi-multi unsigned" {
- if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
var op1: u256 = 0x998888efefefefefefefef;
var op2: u256 = 0x333000abababababababab;
@@ -1053,7 +1059,10 @@ test "big.int mulWrap multi-multi unsigned" {
}
test "big.int mulWrap multi-multi signed" {
- if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
var a = try Managed.initSet(testing.allocator, maxInt(SignedDoubleLimb) - 1);
defer a.deinit();
@@ -1374,6 +1383,8 @@ test "big.int div trunc single-single -/-" {
}
test "big.int divTrunc #15535" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var one = try Managed.initSet(testing.allocator, 1);
defer one.deinit();
var x = try Managed.initSet(testing.allocator, std.math.pow(u128, 2, 64));
@@ -1438,6 +1449,8 @@ test "big.int divFloor #11166" {
}
test "big.int gcd #10932" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Managed.init(testing.allocator);
defer a.deinit();
@@ -1683,7 +1696,10 @@ 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;
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
var a = try Managed.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111);
defer a.deinit();
@@ -2097,6 +2113,8 @@ test "big.int sat shift-left signed simple positive" {
}
test "big.int sat shift-left signed multi positive" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var x: SignedDoubleLimb = 1;
const shift = @bitSizeOf(SignedDoubleLimb) - 1;
@@ -2108,6 +2126,8 @@ test "big.int sat shift-left signed multi positive" {
}
test "big.int sat shift-left signed multi negative" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var x: SignedDoubleLimb = -1;
const shift = @bitSizeOf(SignedDoubleLimb) - 1;
@@ -2468,6 +2488,8 @@ test "big.int var args" {
}
test "big.int gcd non-one small" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Managed.initSet(testing.allocator, 17);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 97);
@@ -2481,6 +2503,8 @@ test "big.int gcd non-one small" {
}
test "big.int gcd non-one medium" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Managed.initSet(testing.allocator, 4864);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 3458);
@@ -2494,6 +2518,8 @@ test "big.int gcd non-one medium" {
}
test "big.int gcd non-one large" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Managed.initSet(testing.allocator, 0xffffffffffffffff);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 0xffffffffffffffff7777);
@@ -2507,7 +2533,10 @@ test "big.int gcd non-one large" {
}
test "big.int gcd large multi-limb result" {
- if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
var a = try Managed.initSet(testing.allocator, 0x12345678123456781234567812345678123456781234567812345678);
defer a.deinit();
@@ -2523,6 +2552,8 @@ test "big.int gcd large multi-limb result" {
}
test "big.int gcd one large" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Managed.initSet(testing.allocator, 1897056385327307);
defer a.deinit();
var b = try Managed.initSet(testing.allocator, 2251799813685248);
lib/std/math/big/rational.zig
@@ -1,4 +1,5 @@
const std = @import("../../std.zig");
+const builtin = @import("builtin");
const debug = std.debug;
const math = std.math;
const mem = std.mem;
@@ -493,6 +494,8 @@ fn extractLowBits(a: Int, comptime T: type) T {
}
test "big.rational extractLowBits" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Int.initSet(testing.allocator, 0x11112222333344441234567887654321);
defer a.deinit();
@@ -513,6 +516,8 @@ test "big.rational extractLowBits" {
}
test "big.rational set" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
@@ -542,6 +547,8 @@ test "big.rational set" {
}
test "big.rational setFloat" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
@@ -567,6 +574,8 @@ test "big.rational setFloat" {
}
test "big.rational setFloatString" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
@@ -578,6 +587,8 @@ test "big.rational setFloatString" {
}
test "big.rational toFloat" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
@@ -591,6 +602,8 @@ test "big.rational toFloat" {
}
test "big.rational set/to Float round-trip" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
var prng = std.rand.DefaultPrng.init(0x5EED);
@@ -604,6 +617,8 @@ test "big.rational set/to Float round-trip" {
}
test "big.rational copy" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
@@ -634,6 +649,8 @@ test "big.rational copy" {
}
test "big.rational negate" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
@@ -651,6 +668,8 @@ test "big.rational negate" {
}
test "big.rational abs" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
@@ -668,6 +687,8 @@ test "big.rational abs" {
}
test "big.rational swap" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
var b = try Rational.init(testing.allocator);
@@ -692,6 +713,8 @@ test "big.rational swap" {
}
test "big.rational order" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
var b = try Rational.init(testing.allocator);
@@ -707,6 +730,8 @@ test "big.rational order" {
}
test "big.rational order/orderAbs with negative" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
var b = try Rational.init(testing.allocator);
@@ -719,6 +744,8 @@ test "big.rational order/orderAbs with negative" {
}
test "big.rational add single-limb" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
var b = try Rational.init(testing.allocator);
@@ -734,6 +761,8 @@ test "big.rational add single-limb" {
}
test "big.rational add" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
var b = try Rational.init(testing.allocator);
@@ -750,6 +779,8 @@ test "big.rational add" {
}
test "big.rational sub" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
var b = try Rational.init(testing.allocator);
@@ -766,6 +797,8 @@ test "big.rational sub" {
}
test "big.rational mul" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var a = try Rational.init(testing.allocator);
defer a.deinit();
var b = try Rational.init(testing.allocator);
@@ -782,6 +815,8 @@ test "big.rational mul" {
}
test "big.rational div" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
{
var a = try Rational.init(testing.allocator);
defer a.deinit();
lib/std/net/test.zig
@@ -109,6 +109,8 @@ test "parse and render UNIX addresses" {
test "resolve DNS" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (builtin.os.tag == .windows) {
_ = try std.os.windows.WSAStartup(2, 2);
}
@@ -291,6 +293,8 @@ test "listen on a unix socket, send bytes, receive bytes" {
if (builtin.single_threaded) return error.SkipZigTest;
if (!net.has_unix_sockets) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (builtin.os.tag == .windows) {
_ = try std.os.windows.WSAStartup(2, 2);
}
lib/std/os/linux/io_uring.zig
@@ -1741,6 +1741,8 @@ test "readv" {
test "writev/fsync/readv" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(4, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -1811,6 +1813,8 @@ test "writev/fsync/readv" {
test "write/read" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(2, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -1929,6 +1933,8 @@ test "splice/read" {
test "write_fixed/read_fixed" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(2, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -1994,6 +2000,8 @@ test "write_fixed/read_fixed" {
test "openat" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -2045,6 +2053,8 @@ test "openat" {
test "close" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -2204,6 +2214,8 @@ test "sendmsg/recvmsg" {
test "timeout (after a relative time)" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -2376,6 +2388,8 @@ test "accept/connect/recv/link_timeout" {
test "fallocate" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -2422,6 +2436,8 @@ test "fallocate" {
test "statx" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -2678,6 +2694,8 @@ test "shutdown" {
test "renameat" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -2747,6 +2765,8 @@ test "renameat" {
test "unlinkat" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -2799,6 +2819,8 @@ test "unlinkat" {
test "mkdirat" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -2843,6 +2865,8 @@ test "mkdirat" {
test "symlinkat" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
@@ -2891,6 +2915,8 @@ test "symlinkat" {
test "linkat" {
if (builtin.os.tag != .linux) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
error.SystemOutdated => return error.SkipZigTest,
error.PermissionDenied => return error.SkipZigTest,
lib/std/os/linux/test.zig
@@ -8,6 +8,8 @@ const expectEqual = std.testing.expectEqual;
const fs = std.fs;
test "fallocate" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
@@ -69,6 +71,8 @@ test "timer" {
}
test "statx" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
@@ -107,6 +111,8 @@ test "user and group ids" {
}
test "fadvise" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
lib/std/os/test.zig
@@ -88,6 +88,8 @@ test "chdir smoke test" {
test "open smoke test" {
if (native_os == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// TODO verify file attributes using `fstat`
var tmp = tmpDir(.{});
@@ -142,6 +144,8 @@ test "open smoke test" {
test "openat smoke test" {
if (native_os == .wasi and builtin.link_libc) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
// TODO verify file attributes using `fstatat`
var tmp = tmpDir(.{});
@@ -276,6 +280,8 @@ test "link with relative paths" {
test "linkat with different directories" {
if (native_os == .wasi and builtin.link_libc) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
switch (native_os) {
.wasi, .linux, .solaris, .illumos => {},
else => return error.SkipZigTest,
@@ -321,6 +327,8 @@ test "fstatat" {
// enable when `fstat` and `fstatat` are implemented on Windows
if (native_os == .windows) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -340,6 +348,8 @@ test "fstatat" {
}
test "readlinkat" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -566,6 +576,8 @@ test "mmap" {
if (native_os == .windows or native_os == .wasi)
return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -676,6 +688,8 @@ test "fcntl" {
if (native_os == .windows or native_os == .wasi)
return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -716,6 +730,8 @@ test "sync" {
if (native_os != .linux)
return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -736,6 +752,8 @@ test "fsync" {
else => return error.SkipZigTest,
}
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -874,6 +892,8 @@ test "dup & dup2" {
else => return error.SkipZigTest,
}
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -903,6 +923,8 @@ test "dup & dup2" {
test "writev longer than IOV_MAX" {
if (native_os == .windows or native_os == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -920,6 +942,8 @@ test "POSIX file locking with fcntl" {
return error.SkipZigTest;
}
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (true) {
// https://github.com/ziglang/zig/issues/11074
return error.SkipZigTest;
@@ -982,6 +1006,8 @@ test "POSIX file locking with fcntl" {
test "rename smoke test" {
if (native_os == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1038,6 +1064,8 @@ test "rename smoke test" {
test "access smoke test" {
if (native_os == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1102,6 +1130,8 @@ test "timerfd" {
}
test "isatty" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1114,6 +1144,8 @@ test "isatty" {
test "read with empty buffer" {
if (native_os == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1139,6 +1171,8 @@ test "read with empty buffer" {
test "pread with empty buffer" {
if (native_os == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1164,6 +1198,8 @@ test "pread with empty buffer" {
test "write with empty buffer" {
if (native_os == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1189,6 +1225,8 @@ test "write with empty buffer" {
test "pwrite with empty buffer" {
if (native_os == .wasi) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
@@ -1214,6 +1252,8 @@ test "pwrite with empty buffer" {
test "fchmodat smoke test" {
if (!std.fs.has_executable_bit) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var tmp = tmpDir(.{});
defer tmp.cleanup();
lib/std/rand/test.zig
@@ -436,6 +436,8 @@ fn testRangeBias(r: Random, start: i8, end: i8, biased: bool) !void {
}
test "CSPRNG" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var secret_seed: [DefaultCsprng.secret_seed_length]u8 = undefined;
std.crypto.random.bytes(&secret_seed);
var csprng = DefaultCsprng.init(secret_seed);
lib/std/rand/Xoshiro256.zig
@@ -90,7 +90,10 @@ pub fn fill(self: *Xoshiro256, buf: []u8) void {
}
test "xoroshiro sequence" {
- if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
+ switch (@import("builtin").zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
var r = Xoshiro256.init(0);
lib/std/zig/CrossTarget.zig
@@ -785,6 +785,8 @@ fn parseOs(result: *CrossTarget, diags: *ParseOptions.Diagnostics, text: []const
}
test "CrossTarget.parse" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (builtin.target.isGnuLibC()) {
var cross_target = try CrossTarget.parse(.{});
cross_target.setGnuLibCVersion(2, 1, 1);
lib/std/zig/tokenizer.zig
@@ -1478,6 +1478,8 @@ test "utf8" {
}
test "invalid utf8" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testTokenize("//\x80", &.{
.invalid,
});
lib/std/base64.zig
@@ -1,5 +1,6 @@
const std = @import("std.zig");
const assert = std.debug.assert;
+const builtin = @import("builtin");
const testing = std.testing;
const mem = std.mem;
@@ -354,12 +355,16 @@ pub const Base64DecoderWithIgnore = struct {
};
test "base64" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
@setEvalBranchQuota(8000);
try testBase64();
try comptime testAllApis(standard, "comptime", "Y29tcHRpbWU=");
}
test "base64 padding dest overflow" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const input = "foo";
var expect: [128]u8 = undefined;
@@ -374,6 +379,8 @@ test "base64 padding dest overflow" {
}
test "base64 url_safe_no_pad" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
@setEvalBranchQuota(8000);
try testBase64UrlSafeNoPad();
try comptime testAllApis(url_safe_no_pad, "comptime", "Y29tcHRpbWU");
lib/std/bit_set.zig
@@ -1636,7 +1636,10 @@ fn testStaticBitSet(comptime Set: type) !void {
}
test "IntegerBitSet" {
- if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
+ switch (@import("builtin").zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
try testStaticBitSet(IntegerBitSet(0));
try testStaticBitSet(IntegerBitSet(1));
@@ -1649,6 +1652,11 @@ test "IntegerBitSet" {
}
test "ArrayBitSet" {
+ switch (@import("builtin").zig_backend) {
+ .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
+
inline for (.{ 0, 1, 2, 31, 32, 33, 63, 64, 65, 254, 500, 3000 }) |size| {
try testStaticBitSet(ArrayBitSet(u8, size));
try testStaticBitSet(ArrayBitSet(u16, size));
lib/std/crypto.zig
@@ -314,6 +314,8 @@ test "CSPRNG" {
}
test "issue #4532: no index out of bounds" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const types = [_]type{
hash.Md5,
hash.Sha1,
lib/std/fmt.zig
@@ -2735,6 +2735,8 @@ test "formatType max_depth" {
}
test "positional" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try expectFmt("2 1 0", "{2} {1} {0}", .{ @as(usize, 0), @as(usize, 1), @as(usize, 2) });
try expectFmt("2 1 0", "{2} {1} {}", .{ @as(usize, 0), @as(usize, 1), @as(usize, 2) });
try expectFmt("0 0", "{0} {0}", .{@as(usize, 0)});
@@ -2743,14 +2745,20 @@ test "positional" {
}
test "positional with specifier" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try expectFmt("10.0", "{0d:.1}", .{@as(f64, 9.999)});
}
test "positional/alignment/width/precision" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try expectFmt("10.0", "{0d: >3.1}", .{@as(f64, 9.999)});
}
test "vector" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (builtin.target.cpu.arch == .riscv64) {
// https://github.com/ziglang/zig/issues/4486
return error.SkipZigTest;
lib/std/fs.zig
@@ -3167,13 +3167,15 @@ fn copy_file(fd_in: os.fd_t, fd_out: os.fd_t, maybe_size: ?u64) CopyFileRawError
}
test {
- if (builtin.os.tag != .wasi) {
- _ = &makeDirAbsolute;
- _ = &makeDirAbsoluteZ;
- _ = ©FileAbsolute;
- _ = &updateFileAbsolute;
+ if (builtin.zig_backend != .stage2_x86_64) {
+ if (builtin.os.tag != .wasi) {
+ _ = &makeDirAbsolute;
+ _ = &makeDirAbsoluteZ;
+ _ = ©FileAbsolute;
+ _ = &updateFileAbsolute;
+ }
+ _ = &Dir.copyFile;
}
- _ = &Dir.copyFile;
_ = @import("fs/test.zig");
_ = @import("fs/path.zig");
_ = @import("fs/file.zig");
lib/std/json.zig
@@ -9,6 +9,7 @@
//! The low-level `writeStream` emits syntax-conformant JSON tokens to a `std.io.Writer`.
//! The high-level `stringify` serializes a Zig or `Value` type into JSON.
+const builtin = @import("builtin");
const testing = @import("std").testing;
const ArrayList = @import("std").ArrayList;
@@ -23,6 +24,8 @@ test Scanner {
}
test parseFromSlice {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var parsed_str = try parseFromSlice([]const u8, testing.allocator, "\"a\\u0020b\"", .{});
defer parsed_str.deinit();
try testing.expectEqualSlices(u8, "a b", parsed_str.value);
@@ -58,6 +61,8 @@ test writeStream {
}
test stringify {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var out = ArrayList(u8).init(testing.allocator);
defer out.deinit();
lib/std/math.zig
@@ -492,10 +492,13 @@ pub fn shl(comptime T: type, a: T, shift_amt: anytype) T {
}
test "shl" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
// https://github.com/ziglang/zig/issues/12012
return error.SkipZigTest;
}
+
try testing.expect(shl(u8, 0b11111111, @as(usize, 3)) == 0b11111000);
try testing.expect(shl(u8, 0b11111111, @as(usize, 8)) == 0);
try testing.expect(shl(u8, 0b11111111, @as(usize, 9)) == 0);
@@ -536,10 +539,13 @@ pub fn shr(comptime T: type, a: T, shift_amt: anytype) T {
}
test "shr" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
// https://github.com/ziglang/zig/issues/12012
return error.SkipZigTest;
}
+
try testing.expect(shr(u8, 0b11111111, @as(usize, 3)) == 0b00011111);
try testing.expect(shr(u8, 0b11111111, @as(usize, 8)) == 0);
try testing.expect(shr(u8, 0b11111111, @as(usize, 9)) == 0);
@@ -581,10 +587,13 @@ pub fn rotr(comptime T: type, x: T, r: anytype) T {
}
test "rotr" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
// https://github.com/ziglang/zig/issues/12012
return error.SkipZigTest;
}
+
try testing.expect(rotr(u0, 0b0, @as(usize, 3)) == 0b0);
try testing.expect(rotr(u5, 0b00001, @as(usize, 0)) == 0b00001);
try testing.expect(rotr(u6, 0b000001, @as(usize, 7)) == 0b100000);
@@ -625,10 +634,13 @@ pub fn rotl(comptime T: type, x: T, r: anytype) T {
}
test "rotl" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
// https://github.com/ziglang/zig/issues/12012
return error.SkipZigTest;
}
+
try testing.expect(rotl(u0, 0b0, @as(usize, 3)) == 0b0);
try testing.expect(rotl(u5, 0b00001, @as(usize, 0)) == 0b00001);
try testing.expect(rotl(u6, 0b000001, @as(usize, 7)) == 0b000010);
@@ -752,6 +764,8 @@ pub fn divTrunc(comptime T: type, numerator: T, denominator: T) !T {
}
test "divTrunc" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDivTrunc();
try comptime testDivTrunc();
}
@@ -776,6 +790,8 @@ pub fn divFloor(comptime T: type, numerator: T, denominator: T) !T {
}
test "divFloor" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDivFloor();
try comptime testDivFloor();
}
@@ -813,6 +829,8 @@ pub fn divCeil(comptime T: type, numerator: T, denominator: T) !T {
}
test "divCeil" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDivCeil();
try comptime testDivCeil();
}
@@ -857,6 +875,8 @@ pub fn divExact(comptime T: type, numerator: T, denominator: T) !T {
}
test "divExact" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testDivExact();
try comptime testDivExact();
}
@@ -887,6 +907,8 @@ test "mod" {
try comptime testMod();
}
fn testMod() !void {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testing.expect((mod(i32, -5, 3) catch unreachable) == 1);
try testing.expect((mod(i32, 5, 3) catch unreachable) == 2);
try testing.expectError(error.NegativeDenominator, mod(i32, 10, -1));
@@ -909,6 +931,8 @@ pub fn rem(comptime T: type, numerator: T, denominator: T) !T {
}
test "rem" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testRem();
try comptime testRem();
}
@@ -1258,6 +1282,8 @@ pub fn lerp(a: anytype, b: anytype, t: anytype) @TypeOf(a, b, t) {
}
test "lerp" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testing.expectEqual(@as(f64, 75), lerp(50, 100, 0.5));
try testing.expectEqual(@as(f32, 43.75), lerp(50, 25, 0.25));
try testing.expectEqual(@as(f64, -31.25), lerp(-50, 25, 0.25));
lib/std/mem.zig
@@ -315,6 +315,8 @@ pub fn zeroes(comptime T: type) T {
}
test "zeroes" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const C_struct = extern struct {
x: u32,
y: u32 align(128),
@@ -1737,6 +1739,8 @@ pub fn readIntSlice(comptime T: type, bytes: []const u8, endian: Endian) T {
}
test "comptime read/write int" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
comptime {
var bytes: [2]u8 = undefined;
writeIntLittle(u16, &bytes, 0x1234);
@@ -1752,7 +1756,10 @@ test "comptime read/write int" {
}
test "readIntBig and readIntLittle" {
- if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
try testing.expect(readIntSliceBig(u0, &[_]u8{}) == 0x0);
try testing.expect(readIntSliceLittle(u0, &[_]u8{}) == 0x0);
@@ -2053,7 +2060,10 @@ 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;
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
var buf0: [0]u8 = undefined;
var buf1: [1]u8 = undefined;
@@ -3297,6 +3307,8 @@ test "testStringEquality" {
}
test "testReadInt" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testReadIntImpl();
try comptime testReadIntImpl();
}
@@ -4650,8 +4662,10 @@ pub fn alignInSlice(slice: anytype, comptime new_alignment: usize) ?AlignedSlice
}
test "read/write(Var)PackedInt" {
- if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-
+ switch (builtin.zig_backend) {
+ .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
+ else => {},
+ }
switch (builtin.cpu.arch) {
// This test generates too much code to execute on WASI.
// LLVM backend fails with "too many locals: locals exceed maximum"
lib/std/multi_array_list.zig
@@ -583,6 +583,8 @@ pub fn MultiArrayList(comptime T: type) type {
}
test "basic usage" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const ally = testing.allocator;
const Foo = struct {
@@ -677,6 +679,8 @@ test "basic usage" {
// This was observed to fail on aarch64 with LLVM 11, when the capacityInBytes
// function used the @reduce code path.
test "regression test for @reduce bug" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const ally = testing.allocator;
var list = MultiArrayList(struct {
tag: std.zig.Token.Tag,
@@ -754,6 +758,8 @@ test "regression test for @reduce bug" {
}
test "ensure capacity on empty list" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const ally = testing.allocator;
const Foo = struct {
@@ -789,6 +795,8 @@ test "ensure capacity on empty list" {
}
test "insert elements" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const ally = testing.allocator;
const Foo = struct {
@@ -808,6 +816,8 @@ test "insert elements" {
}
test "union" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const ally = testing.allocator;
const Foo = union(enum) {
@@ -863,6 +873,8 @@ test "union" {
}
test "sorting a span" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var list: MultiArrayList(struct { score: u32, chr: u8 }) = .{};
defer list.deinit(testing.allocator);
@@ -903,6 +915,8 @@ test "sorting a span" {
}
test "0 sized struct field" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const ally = testing.allocator;
const Foo = struct {
@@ -930,6 +944,8 @@ test "0 sized struct field" {
}
test "0 sized struct" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const ally = testing.allocator;
const Foo = struct {
lib/std/simd.zig
@@ -196,10 +196,13 @@ pub fn extract(
}
test "vector patterns" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
// https://github.com/ziglang/zig/issues/12012
return error.SkipZigTest;
}
+
const base = @Vector(4, u32){ 10, 20, 30, 40 };
const other_base = @Vector(4, u32){ 55, 66, 77, 88 };
@@ -269,6 +272,8 @@ pub fn reverseOrder(vec: anytype) @TypeOf(vec) {
}
test "vector shifting" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const base = @Vector(4, u32){ 10, 20, 30, 40 };
try std.testing.expectEqual([4]u32{ 30, 40, 999, 999 }, shiftElementsLeft(base, 2, 999));
@@ -333,6 +338,8 @@ pub fn countElementsWithValue(vec: anytype, value: std.meta.Child(@TypeOf(vec)))
}
test "vector searching" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const base = @Vector(8, u32){ 6, 4, 7, 4, 4, 2, 3, 7 };
try std.testing.expectEqual(@as(?u3, 1), firstIndexOfValue(base, 4));
@@ -424,6 +431,8 @@ pub fn prefixScan(comptime op: std.builtin.ReduceOp, comptime hop: isize, vec: a
}
test "vector prefix scan" {
+ if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
if (comptime builtin.cpu.arch.isMIPS()) {
return error.SkipZigTest;
}
lib/std/time.zig
@@ -122,6 +122,8 @@ pub fn nanoTimestamp() i128 {
}
test "timestamp" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const margin = ns_per_ms * 50;
const time_0 = milliTimestamp();
@@ -319,6 +321,8 @@ pub const Timer = struct {
};
test "Timer + Instant" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const margin = ns_per_ms * 150;
var timer = try Timer.start();
lib/std/unicode.zig
@@ -1,5 +1,6 @@
const std = @import("./std.zig");
const assert = std.debug.assert;
+const builtin = @import("builtin");
const testing = std.testing;
const mem = std.mem;
@@ -499,11 +500,15 @@ fn testUtf16CountCodepoints() !void {
}
test "utf16 count codepoints" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testUtf16CountCodepoints();
try comptime testUtf16CountCodepoints();
}
test "utf8 encode" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try comptime testUtf8Encode();
try testUtf8Encode();
}
@@ -530,6 +535,8 @@ fn testUtf8Encode() !void {
}
test "utf8 encode error" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try comptime testUtf8EncodeError();
try testUtf8EncodeError();
}
@@ -546,6 +553,8 @@ fn testErrorEncode(codePoint: u21, array: []u8, expectedErr: anyerror) !void {
}
test "utf8 iterator on ascii" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try comptime testUtf8IteratorOnAscii();
try testUtf8IteratorOnAscii();
}
@@ -566,6 +575,8 @@ fn testUtf8IteratorOnAscii() !void {
}
test "utf8 view bad" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try comptime testUtf8ViewBad();
try testUtf8ViewBad();
}
@@ -576,6 +587,8 @@ fn testUtf8ViewBad() !void {
}
test "utf8 view ok" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try comptime testUtf8ViewOk();
try testUtf8ViewOk();
}
@@ -596,6 +609,8 @@ fn testUtf8ViewOk() !void {
}
test "validate slice" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try comptime testValidateSlice();
try testValidateSlice();
@@ -636,6 +651,8 @@ fn testValidateSlice() !void {
}
test "valid utf8" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try comptime testValidUtf8();
try testValidUtf8();
}
@@ -655,6 +672,8 @@ fn testValidUtf8() !void {
}
test "invalid utf8 continuation bytes" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try comptime testInvalidUtf8ContinuationBytes();
try testInvalidUtf8ContinuationBytes();
}
@@ -687,6 +706,8 @@ fn testInvalidUtf8ContinuationBytes() !void {
}
test "overlong utf8 codepoint" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try comptime testOverlongUtf8Codepoint();
try testOverlongUtf8Codepoint();
}
@@ -700,6 +721,8 @@ fn testOverlongUtf8Codepoint() !void {
}
test "misc invalid utf8" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try comptime testMiscInvalidUtf8();
try testMiscInvalidUtf8();
}
@@ -715,6 +738,8 @@ fn testMiscInvalidUtf8() !void {
}
test "utf8 iterator peeking" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try comptime testUtf8Peeking();
try testUtf8Peeking();
}
@@ -799,6 +824,8 @@ pub fn utf16leToUtf8(utf8: []u8, utf16le: []const u16) !usize {
}
test "utf16leToUtf8" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var utf16le: [2]u16 = undefined;
const utf16le_as_bytes = mem.sliceAsBytes(utf16le[0..]);
@@ -911,6 +938,8 @@ pub fn utf8ToUtf16Le(utf16le: []u16, utf8: []const u8) !usize {
}
test "utf8ToUtf16Le" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
var utf16le: [2]u16 = [_]u16{0} ** 2;
{
const length = try utf8ToUtf16Le(utf16le[0..], "𐐷");
@@ -929,6 +958,8 @@ test "utf8ToUtf16Le" {
}
test "utf8ToUtf16LeWithNull" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
{
const utf16 = try utf8ToUtf16LeWithNull(testing.allocator, "𐐷");
defer testing.allocator.free(utf16);
@@ -987,6 +1018,8 @@ fn testCalcUtf16LeLen() !void {
}
test "calculate utf16 string length of given utf8 string in u16" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testCalcUtf16LeLen();
try comptime testCalcUtf16LeLen();
}
@@ -1020,6 +1053,8 @@ pub fn fmtUtf16le(utf16le: []const u16) std.fmt.Formatter(formatUtf16le) {
}
test "fmtUtf16le" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
const expectFmt = std.testing.expectFmt;
try expectFmt("", "{}", .{fmtUtf16le(utf8ToUtf16LeStringLiteral(""))});
try expectFmt("foo", "{}", .{fmtUtf16le(utf8ToUtf16LeStringLiteral("foo"))});
@@ -1033,6 +1068,8 @@ test "fmtUtf16le" {
}
test "utf8ToUtf16LeStringLiteral" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
{
const bytes = [_:0]u16{
mem.nativeToLittle(u16, 0x41),
@@ -1093,6 +1130,8 @@ fn testUtf8CountCodepoints() !void {
}
test "utf8 count codepoints" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testUtf8CountCodepoints();
try comptime testUtf8CountCodepoints();
}
@@ -1109,6 +1148,8 @@ fn testUtf8ValidCodepoint() !void {
}
test "utf8 valid codepoint" {
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
try testUtf8ValidCodepoint();
try comptime testUtf8ValidCodepoint();
}
src/arch/x86_64/CodeGen.zig
@@ -2979,8 +2979,21 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
const dst_mcv = if (src_mcv.isRegister() and self.reuseOperand(inst, ty_op.operand, 0, src_mcv))
src_mcv
- else
- try self.copyToRegisterWithInstTracking(inst, dst_ty, src_mcv);
+ else if (dst_abi_size <= 8)
+ try self.copyToRegisterWithInstTracking(inst, dst_ty, src_mcv)
+ else if (dst_abi_size <= 16) dst: {
+ const dst_regs = try self.register_manager.allocRegs(
+ 2,
+ .{ inst, inst },
+ abi.RegisterClass.gp,
+ );
+ const dst_mcv: MCValue = .{ .register_pair = dst_regs };
+ const dst_locks = self.register_manager.lockRegsAssumeUnused(2, dst_regs);
+ defer for (dst_locks) |lock| self.register_manager.unlockReg(lock);
+
+ try self.genCopy(dst_ty, dst_mcv, src_mcv);
+ break :dst dst_mcv;
+ } else return self.fail("TODO implement trunc from {} to {}", .{ src_ty.fmt(mod), dst_ty.fmt(mod) });
if (dst_ty.zigTypeTag(mod) == .Vector) {
assert(src_ty.zigTypeTag(mod) == .Vector and dst_ty.vectorLen(mod) == src_ty.vectorLen(mod));
@@ -3051,14 +3064,15 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
break :result dst_mcv;
}
- if (dst_abi_size > 8) {
- return self.fail("TODO implement trunc for abi sizes larger than 8", .{});
- }
-
// when truncating a `u16` to `u5`, for example, those top 3 bits in the result
// have to be removed. this only happens if the dst if not a power-of-two size.
- if (self.regExtraBits(dst_ty) > 0)
- try self.truncateRegister(dst_ty, dst_mcv.register.to64());
+ if (dst_abi_size <= 8) {
+ if (self.regExtraBits(dst_ty) > 0) try self.truncateRegister(dst_ty, dst_mcv.register.to64());
+ } else if (dst_abi_size <= 16) {
+ const dst_info = dst_ty.intInfo(mod);
+ const high_ty = try mod.intType(dst_info.signedness, dst_info.bits - 64);
+ if (self.regExtraBits(high_ty) > 0) try self.truncateRegister(high_ty, dst_mcv.register_pair[1].to64());
+ }
break :result dst_mcv;
};
@@ -3381,7 +3395,7 @@ fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
const cc: Condition = if (ty.isSignedInt(mod)) cc: {
try self.genSetReg(limit_reg, ty, lhs_mcv);
try self.genBinOpMir(.{ ._, .xor }, ty, limit_mcv, rhs_mcv);
- try self.genShiftBinOpMir(.{ ._, .sa }, ty, limit_mcv, .{ .immediate = reg_bits - 1 });
+ try self.genShiftBinOpMir(.{ ._r, .sa }, ty, limit_mcv, .{ .immediate = reg_bits - 1 });
try self.genBinOpMir(.{ ._, .xor }, ty, limit_mcv, .{
.immediate = (@as(u64, 1) << @intCast(reg_bits - 1)) - 1,
});
@@ -4949,7 +4963,7 @@ fn byteSwap(self: *Self, inst: Air.Inst.Index, src_ty: Type, src_mcv: MCValue, m
const mod = self.bin_file.options.module.?;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
- if (src_ty.zigTypeTag(mod) == .Vector or src_ty.abiSize(mod) > 8) return self.fail(
+ if (src_ty.zigTypeTag(mod) == .Vector) return self.fail(
"TODO implement byteSwap for {}",
.{src_ty.fmt(mod)},
);
@@ -10493,39 +10507,44 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
},
else => return self.fail("invalid constraint: '{s}'", .{constraint}),
};
- const arg_maybe_reg: ?Register = if (mem.eql(u8, constraint[1..], "r"))
- self.register_manager.tryAllocReg(maybe_inst, self.regClassForType(ty)) orelse
- return self.fail("ran out of registers lowering inline asm", .{})
- else if (mem.eql(u8, constraint[1..], "m"))
- if (output != .none) null else return self.fail(
- "memory constraint unsupported for asm result: '{s}'",
- .{constraint},
- )
- else if (mem.eql(u8, constraint[1..], "g") or
- mem.eql(u8, constraint[1..], "rm") or mem.eql(u8, constraint[1..], "mr") or
- mem.eql(u8, constraint[1..], "r,m") or mem.eql(u8, constraint[1..], "m,r"))
- self.register_manager.tryAllocReg(maybe_inst, self.regClassForType(ty)) orelse
- if (output != .none)
- null
- else
- return self.fail("ran out of registers lowering inline asm", .{})
- else if (mem.startsWith(u8, constraint[1..], "{") and mem.endsWith(u8, constraint[1..], "}"))
- parseRegName(constraint[1 + "{".len .. constraint.len - "}".len]) orelse
- return self.fail("invalid register constraint: '{s}'", .{constraint})
- else
- return self.fail("invalid constraint: '{s}'", .{constraint});
- const arg_mcv: MCValue = if (arg_maybe_reg) |reg| .{ .register = reg } else arg: {
- const ptr_mcv = try self.resolveInst(output);
- switch (ptr_mcv) {
- .immediate => |addr| if (math.cast(i32, @as(i64, @bitCast(addr)))) |_|
- break :arg ptr_mcv.deref(),
- .register, .register_offset, .lea_frame => break :arg ptr_mcv.deref(),
- else => {},
- }
- break :arg .{ .indirect = .{ .reg = try self.copyToTmpRegister(Type.usize, ptr_mcv) } };
+ const arg_mcv: MCValue = arg_mcv: {
+ const arg_maybe_reg: ?Register = if (mem.eql(u8, constraint[1..], "r"))
+ self.register_manager.tryAllocReg(maybe_inst, self.regClassForType(ty)) orelse
+ return self.fail("ran out of registers lowering inline asm", .{})
+ else if (mem.eql(u8, constraint[1..], "m"))
+ if (output != .none) null else return self.fail(
+ "memory constraint unsupported for asm result: '{s}'",
+ .{constraint},
+ )
+ else if (mem.eql(u8, constraint[1..], "g") or
+ mem.eql(u8, constraint[1..], "rm") or mem.eql(u8, constraint[1..], "mr") or
+ mem.eql(u8, constraint[1..], "r,m") or mem.eql(u8, constraint[1..], "m,r"))
+ self.register_manager.tryAllocReg(maybe_inst, self.regClassForType(ty)) orelse
+ if (output != .none)
+ null
+ else
+ return self.fail("ran out of registers lowering inline asm", .{})
+ else if (mem.startsWith(u8, constraint[1..], "{") and mem.endsWith(u8, constraint[1..], "}"))
+ parseRegName(constraint[1 + "{".len .. constraint.len - "}".len]) orelse
+ return self.fail("invalid register constraint: '{s}'", .{constraint})
+ else if (constraint.len == 2 and std.ascii.isDigit(constraint[1])) {
+ const index = std.fmt.charToDigit(constraint[0], 10) catch unreachable;
+ if (index >= args.items.len) return self.fail("constraint out of bounds: '{s}'", .{constraint});
+ break :arg_mcv args.items[index];
+ } else return self.fail("invalid constraint: '{s}'", .{constraint});
+ break :arg_mcv if (arg_maybe_reg) |reg| .{ .register = reg } else arg: {
+ const ptr_mcv = try self.resolveInst(output);
+ switch (ptr_mcv) {
+ .immediate => |addr| if (math.cast(i32, @as(i64, @bitCast(addr)))) |_|
+ break :arg ptr_mcv.deref(),
+ .register, .register_offset, .lea_frame => break :arg ptr_mcv.deref(),
+ else => {},
+ }
+ break :arg .{ .indirect = .{ .reg = try self.copyToTmpRegister(Type.usize, ptr_mcv) } };
+ };
};
if (arg_mcv.getReg()) |reg| if (RegisterManager.indexOfRegIntoTracked(reg)) |_| {
- _ = self.register_manager.lockRegAssumeUnused(reg);
+ _ = self.register_manager.lockReg(reg);
};
if (!mem.eql(u8, name, "_"))
arg_map.putAssumeCapacityNoClobber(name, @intCast(args.items.len));
@@ -10587,6 +10606,10 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
try self.register_manager.getReg(reg, null);
try self.genSetReg(reg, ty, input_mcv);
break :arg .{ .register = reg };
+ } else if (constraint.len == 1 and std.ascii.isDigit(constraint[0])) arg: {
+ const index = std.fmt.charToDigit(constraint[0], 10) catch unreachable;
+ if (index >= args.items.len) return self.fail("constraint out of bounds: '{s}'", .{constraint});
+ break :arg args.items[index];
} else return self.fail("invalid constraint: '{s}'", .{constraint});
if (arg_mcv.getReg()) |reg| if (RegisterManager.indexOfRegIntoTracked(reg)) |_| {
_ = self.register_manager.lockReg(reg);
@@ -10712,7 +10735,7 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
mnem_name[mnem_prefix.len .. mnem_name.len - mnem_suffix.len],
) orelse continue };
} else {
- assert(prefix != .none);
+ assert(prefix != .none); // no combination of fixes produced a known mnemonic
return self.fail("invalid prefix for mnemonic: '{s} {s}'", .{
@tagName(prefix), mnem_str,
});
@@ -10943,6 +10966,7 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
if (output == .none) continue;
if (arg_mcv != .register) continue;
+ if (constraint.len == 2 and std.ascii.isDigit(constraint[1])) continue;
try self.store(self.typeOf(output), .{ .air_ref = output }, arg_mcv);
}
@@ -11036,6 +11060,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {
else => {},
},
.Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
+ .Bool => return .{ .move = .{ ._, .mov } },
.Int => switch (ty.childType(mod).intInfo(mod).bits) {
8 => switch (ty.vectorLen(mod)) {
1 => if (self.hasFeature(.avx)) return .{ .vex_insert_extract = .{
src/arch/x86_64/Encoding.zig
@@ -232,7 +232,7 @@ pub const Mnemonic = enum {
cmp,
cmps, cmpsb, cmpsd, cmpsq, cmpsw,
cmpxchg, cmpxchg8b, cmpxchg16b,
- cqo, cwd, cwde,
+ cpuid, cqo, cwd, cwde,
div,
idiv, imul, int3,
ja, jae, jb, jbe, jc, jrcxz, je, jg, jge, jl, jle, jna, jnae, jnb, jnbe,
@@ -246,7 +246,7 @@ pub const Mnemonic = enum {
movsx, movsxd, movzx, mul,
neg, nop, not,
@"or",
- pop, popcnt, push,
+ pause, pop, popcnt, push,
rcl, rcr, ret, rol, ror,
sal, sar, sbb,
scas, scasb, scasd, scasq, scasw,
@@ -258,7 +258,7 @@ pub const Mnemonic = enum {
stos, stosb, stosd, stosq, stosw,
@"test", tzcnt,
ud2,
- xadd, xchg, xor,
+ xadd, xchg, xgetbv, xor,
// X87
fabs, fchs, ffree, fisttp, fld, fst, fstp,
// MMX
src/arch/x86_64/encodings.zig
@@ -266,6 +266,8 @@ pub const table = [_]Entry{
.{ .cmpxchg8b, .m, &.{ .m64 }, &.{ 0x0f, 0xc7 }, 1, .none, .none },
.{ .cmpxchg16b, .m, &.{ .m128 }, &.{ 0x0f, 0xc7 }, 1, .long, .none },
+ .{ .cpuid, .np, &.{}, &.{ 0x0f, 0xa2 }, 0, .none, .none },
+
.{ .div, .m, &.{ .rm8 }, &.{ 0xf6 }, 6, .none, .none },
.{ .div, .m, &.{ .rm8 }, &.{ 0xf6 }, 6, .rex, .none },
.{ .div, .m, &.{ .rm16 }, &.{ 0xf7 }, 6, .short, .none },
@@ -469,6 +471,8 @@ pub const table = [_]Entry{
.{ .@"or", .rm, &.{ .r32, .rm32 }, &.{ 0x0b }, 0, .none, .none },
.{ .@"or", .rm, &.{ .r64, .rm64 }, &.{ 0x0b }, 0, .long, .none },
+ .{ .pause, .np, &.{}, &.{ 0xf3, 0x90 }, 0, .none, .none },
+
.{ .pop, .o, &.{ .r16 }, &.{ 0x58 }, 0, .short, .none },
.{ .pop, .o, &.{ .r64 }, &.{ 0x58 }, 0, .none, .none },
.{ .pop, .m, &.{ .rm16 }, &.{ 0x8f }, 0, .short, .none },
@@ -805,6 +809,8 @@ pub const table = [_]Entry{
.{ .xchg, .rm, &.{ .r32, .rm32 }, &.{ 0x87 }, 0, .none, .none },
.{ .xchg, .rm, &.{ .r64, .rm64 }, &.{ 0x87 }, 0, .long, .none },
+ .{ .xgetbv, .np, &.{}, &.{ 0x0f, 0x01 }, 0, .none, .none },
+
.{ .xor, .zi, &.{ .al, .imm8 }, &.{ 0x34 }, 0, .none, .none },
.{ .xor, .zi, &.{ .ax, .imm16 }, &.{ 0x35 }, 0, .short, .none },
.{ .xor, .zi, &.{ .eax, .imm32 }, &.{ 0x35 }, 0, .none, .none },
src/arch/x86_64/Mir.zig
@@ -327,6 +327,8 @@ pub const Inst = struct {
/// Compare and exchange
/// Compare and exchange bytes
cmpxchg,
+ /// CPU identification
+ cpuid,
/// Convert doubleword to quadword
cqo,
/// Convert word to doubleword
@@ -386,6 +388,8 @@ pub const Inst = struct {
/// Bitwise logical or of packed single-precision floating-point values
/// Bitwise logical or of packed double-precision floating-point values
@"or",
+ /// Spin loop hint
+ pause,
/// Pop
pop,
/// Return the count of number of bits set to 1
@@ -437,6 +441,8 @@ pub const Inst = struct {
xadd,
/// Exchange register/memory with register
xchg,
+ /// Get value of extended control register
+ xgetbv,
/// Logical exclusive-or
/// Bitwise logical xor of packed single-precision floating-point values
/// Bitwise logical xor of packed double-precision floating-point values
test/behavior/bugs/920.zig
@@ -57,11 +57,11 @@ const NormalDist = blk: {
};
test "bug 920 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 == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
const NormalDist1 = blk: {
break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case);
test/behavior/bitcast.zig
@@ -411,8 +411,9 @@ test "bitcast nan float does not 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_spirv64) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) 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;
test/behavior/cast.zig
@@ -1606,8 +1606,8 @@ 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_sparc64) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
const i: u8 = 100;
var f: f32 = 1.234;
@@ -2372,7 +2372,7 @@ test "@intFromBool on vector" {
}
test "numeric coercions with undefined" {
- if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
const from: i32 = undefined;
var to: f32 = from;
@@ -2390,11 +2390,11 @@ test "15-bit int to float" {
}
test "@as does not corrupt values with incompatible representations" {
- 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_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
const x: f32 = @as(f16, blk: {
if (false) {
test/behavior/cast_int.zig
@@ -199,7 +199,6 @@ test "load non byte-sized value in union" {
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) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
// note: this bug is triggered by the == operator, expectEqual will hide it
test/behavior/int128.zig
@@ -66,7 +66,6 @@ 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
test/behavior/packed-struct.zig
@@ -659,12 +659,12 @@ 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 packed structs larger than 64 bits
- 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_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
+
const Vec2 = packed struct {
x: f32,
y: f32,
test/behavior/translate_c_macros.zig
@@ -151,11 +151,11 @@ test "string and char literals that are not UTF-8 encoded. Issue #12784" {
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 == .stage2_x86_64 and builtin.target.ofmt != .elf) 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)));
test/behavior/tuple.zig
@@ -370,8 +370,8 @@ 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_sparc64) return error.SkipZigTest; // TODO
+ if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
const StructWithDefault = struct { value: f32 = 42 };
const SomeStruct = struct { array: [4]StructWithDefault };
test/behavior/vector.zig
@@ -1329,8 +1329,8 @@ 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_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
var v = [_]@Vector(3, f32){
.{ 1, 1, 1 },
tools/lldb_pretty_printers.py
@@ -355,17 +355,28 @@ class Module_Decl__Module_Decl_Index_SynthProvider:
def __init__(self, value, _=None): self.value = value
def update(self):
try:
- for frame in self.value.thread:
- mod = frame.FindVariable('mod') or frame.FindVariable('module')
- if mod: break
- else: return
- self.ptr = mod.GetChildMemberWithName('allocated_decls').GetChildAtIndex(self.value.unsigned).address_of.Clone('decl')
+ ip = InternPool_Find(self.value.thread)
+ if not ip: return
+ self.ptr = ip.GetChildMemberWithName('allocated_decls').GetChildAtIndex(self.value.unsigned).address_of.Clone('decl')
except: pass
def has_children(self): return True
def num_children(self): return 1
def get_child_index(self, name): return 0 if name == 'decl' else -1
def get_child_at_index(self, index): return self.ptr if index == 0 else None
+class Module_Namespace__Module_Namespace_Index_SynthProvider:
+ def __init__(self, value, _=None): self.value = value
+ def update(self):
+ try:
+ ip = InternPool_Find(self.value.thread)
+ if not ip: return
+ self.ptr = ip.GetChildMemberWithName('allocated_namespaces').GetChildAtIndex(self.value.unsigned).address_of.Clone('namespace')
+ except: pass
+ def has_children(self): return True
+ def num_children(self): return 1
+ def get_child_index(self, name): return 0 if name == 'namespace' else -1
+ def get_child_at_index(self, index): return self.ptr if index == 0 else None
+
class TagOrPayloadPtr_SynthProvider:
def __init__(self, value, _=None): self.value = value
def update(self):
@@ -440,10 +451,9 @@ class InternPool_Index_SynthProvider:
for encoding_field in encoding_type.fields:
if encoding_field.name == 'data':
if encoding_field.type.IsPointerType():
- data_type = encoding_field.type.GetPointeeType()
extra_index = data.unsigned
- self.data = extra.GetChildAtIndex(extra_index).Cast(data_type).Clone('data')
- extra_index += data_type.num_fields
+ self.data = extra.GetChildAtIndex(extra_index).address_of.Cast(encoding_field.type).deref.Clone('data')
+ extra_index += encoding_field.type.GetPointeeType().num_fields
else:
self.data = data.Cast(encoding_field.type).Clone('data')
elif encoding_field.name == 'trailing':
@@ -700,6 +710,7 @@ def __lldb_init_module(debugger, _=None):
add(debugger, category='zig.stage2', regex=True, type=MultiArrayList_Entry('Air\\.Inst'), identifier='TagAndPayload', synth=True, inline_children=True, summary=True)
add(debugger, category='zig.stage2', regex=True, type='^Air\\.Inst\\.Data\\.Data__struct_[1-9][0-9]*$', inline_children=True, summary=True)
add(debugger, category='zig.stage2', type='Module.Decl::Module.Decl.Index', synth=True)
+ add(debugger, category='zig.stage2', type='Module.Namespace::Module.Namespace.Index', synth=True)
add(debugger, category='zig.stage2', type='Module.LazySrcLoc', identifier='zig_TaggedUnion', synth=True)
add(debugger, category='zig.stage2', type='InternPool.Index', synth=True)
add(debugger, category='zig.stage2', type='InternPool.NullTerminatedString', summary=True)